Merge branch 'master' into epec-kernel

Conflicts:
	src/PolySetCGALEvaluator.cc

71 files changed, 11524 insertions, 1135 deletions

diff --git a/src/AutoUpdater.cc b/src/AutoUpdater.cc
new file mode 100644
index 0000000..b64cc82
--- /dev/null
+++ b/src/AutoUpdater.cc
@@ -0,0 +1,3 @@
+#include "AutoUpdater.h"
+
+AutoUpdater *AutoUpdater::updater_instance = NULL;
diff --git a/src/AutoUpdater.h b/src/AutoUpdater.h
new file mode 100644
index 0000000..18527c8
--- /dev/null
+++ b/src/AutoUpdater.h
@@ -0,0 +1,25 @@
+#ifndef AUTOUPDATER_H_
+#define AUTOUPDATER_H_
+
+#include <QString>
+
+class AutoUpdater
+{
+public:
+	virtual ~AutoUpdater() {}
+	
+	virtual void checkForUpdates() = 0;
+	virtual void setAutomaticallyChecksForUpdates(bool on) = 0;
+	virtual bool automaticallyChecksForUpdates() = 0;
+	virtual void setEnableSnapshots(bool on) = 0;
+	virtual bool enableSnapshots() = 0;
+	virtual QString lastUpdateCheckDate() = 0;
+
+	static AutoUpdater *updater() { return updater_instance; }
+	static void setUpdater(AutoUpdater *updater) { updater_instance = updater; }
+
+protected:
+	static AutoUpdater *updater_instance;
+};
+
+#endif
diff --git a/src/CGALEvaluator.cc b/src/CGALEvaluator.cc
index 4deb3b3..7c483cb 100644
--- a/src/CGALEvaluator.cc
+++ b/src/CGALEvaluator.cc
@@ -179,6 +179,64 @@ CGAL_Nef_polyhedron CGALEvaluator::applyHull(const CgaladvNode &node)
 	return N;
 }
 
+CGAL_Nef_polyhedron CGALEvaluator::applyResize(const CgaladvNode &node)
+{
+	// Based on resize() in Giles Bathgate's RapCAD (but not exactly)
+	CGAL_Nef_polyhedron N;
+	N = applyToChildren(node, CGE_UNION);
+
+	if ( N.isNull() || N.isEmpty() ) return N;
+
+	for (int i=0;i<3;i++) {
+		if (node.newsize[i]<0) {
+			PRINT("WARNING: Cannot resize to sizes less than 0.");
+			return N;
+		}
+	}
+
+	CGAL_Iso_cuboid_3 bb;
+
+	if ( N.dim == 2 ) {
+		CGAL_Iso_rectangle_2e bbox = bounding_box( *N.p2 );
+		CGAL_Point_2e min2(bbox.min()), max2(bbox.max());
+		CGAL_Point_3 min3(min2.x(),min2.y(),0), max3(max2.x(),max2.y(),0);
+		bb = CGAL_Iso_cuboid_3( min3, max3 );
+	}
+	else {
+		bb = bounding_box( *N.p3 );
+	}
+
+	Eigen::Matrix<NT,3,1> scale, bbox_size;
+	scale << 1,1,1;
+	bbox_size << bb.xmax()-bb.xmin(), bb.ymax()-bb.ymin(), bb.zmax()-bb.zmin();
+	for (int i=0;i<3;i++) {
+		if (node.newsize[i]) {
+			if (bbox_size[i]==NT(0)) {
+				PRINT("WARNING: Cannot resize in direction normal to flat object");
+				return N;
+			}
+			else {
+				scale[i] = NT(node.newsize[i]) / bbox_size[i];
+			}
+		}
+	}
+	NT autoscale = scale.maxCoeff();
+	for (int i=0;i<3;i++) {
+		if (node.autosize[i]) scale[i] = autoscale;
+	}
+
+	Eigen::Matrix4d t;
+	t << CGAL::to_double(scale[0]),           0,        0,        0,
+	     0,        CGAL::to_double(scale[1]),           0,        0,
+	     0,        0,        CGAL::to_double(scale[2]),           0,
+	     0,        0,        0,                                   1;
+
+	N.transform( Transform3d( t ) );
+	return N;
+}
+
+
+
 /*
 	Typical visitor behavior:
 	o In prefix: Check if we're cached -> prune
@@ -253,57 +311,7 @@ Response CGALEvaluator::visit(State &state, const TransformNode &node)
 				PRINT("Warning: Transformation matrix contains Not-a-Number and/or Infinity - removing object.");
 				N.reset();
 			}
-
-			// Then apply transform
-			// If there is no geometry under the transform, N will be empty
-			// just silently ignore such nodes
-			if (!N.isNull()) {
-				if (N.dim == 2) {
-					// Unfortunately CGAL provides no transform method for CGAL_Nef_polyhedron2
-					// objects. So we convert in to our internal 2d data format, transform it,
-					// tesselate it and create a new CGAL_Nef_polyhedron2 from it.. What a hack!
-					
-					Eigen::Matrix2f testmat;
-					testmat << node.matrix(0,0), node.matrix(0,1), node.matrix(1,0), node.matrix(1,1);
-					if (testmat.determinant() == 0) {
-						PRINT("Warning: Scaling a 2D object with 0 - removing object");
-						N.reset();
-					}
-					else {
-						CGAL_Aff_transformation2 t(
-							node.matrix(0,0), node.matrix(0,1), node.matrix(0,3),
-							node.matrix(1,0), node.matrix(1,1), node.matrix(1,3), node.matrix(3,3));
-						
-						DxfData *dd = N.convertToDxfData();
-						for (size_t i=0; i < dd->points.size(); i++) {
-							CGAL_Kernel2::Point_2 p = CGAL_Kernel2::Point_2(dd->points[i][0], dd->points[i][1]);
-							p = t.transform(p);
-							dd->points[i][0] = to_double(p.x());
-							dd->points[i][1] = to_double(p.y());
-						}
-						
-						PolySet ps;
-						ps.is2d = true;
-						dxf_tesselate(&ps, *dd, 0, true, false, 0);
-						
-						N = evaluateCGALMesh(ps);
-						delete dd;
-					}
-				}
-				else if (N.dim == 3) {
-					if (node.matrix.matrix().determinant() == 0) {
-						PRINT("Warning: Scaling a 3D object with 0 - removing object");
-						N.reset();
-					}
-					else {
-						CGAL_Aff_transformation t(
-							node.matrix(0,0), node.matrix(0,1), node.matrix(0,2), node.matrix(0,3),
-							node.matrix(1,0), node.matrix(1,1), node.matrix(1,2), node.matrix(1,3),
-							node.matrix(2,0), node.matrix(2,1), node.matrix(2,2), node.matrix(2,3), node.matrix(3,3));
-						N.p3->transform(t);
-					}
-				}
-			}
+			N.transform( node.matrix );
 		}
 		else {
 			N = CGALCache::instance()->get(this->tree.getIdString(node));
@@ -358,6 +366,9 @@ Response CGALEvaluator::visit(State &state, const CgaladvNode &node)
 			case HULL:
 				N = applyHull(node);
 				break;
+			case RESIZE:
+				N = applyResize(node);
+				break;
 			}
 		}
 		else {
diff --git a/src/CGALEvaluator.h b/src/CGALEvaluator.h
index 42af5a1..818f520 100644
--- a/src/CGALEvaluator.h
+++ b/src/CGALEvaluator.h
@@ -34,6 +34,7 @@ private:
 	void process(CGAL_Nef_polyhedron &target, const CGAL_Nef_polyhedron &src, CGALEvaluator::CsgOp op);
 	CGAL_Nef_polyhedron applyToChildren(const AbstractNode &node, CGALEvaluator::CsgOp op);
 	CGAL_Nef_polyhedron applyHull(const CgaladvNode &node);
+	CGAL_Nef_polyhedron applyResize(const CgaladvNode &node);
 
 	std::string currindent;
   typedef std::pair<const AbstractNode *, CGAL_Nef_polyhedron> ChildItem;
diff --git a/src/CGAL_Nef_polyhedron.h b/src/CGAL_Nef_polyhedron.h
index d949a2a..cfab993 100644
--- a/src/CGAL_Nef_polyhedron.h
+++ b/src/CGAL_Nef_polyhedron.h
@@ -4,6 +4,7 @@
 #include "cgalfwd.h"
 #include "memory.h"
 #include <string>
+#include "linalg.h"
 
 class CGAL_Nef_polyhedron
 {
@@ -27,7 +28,7 @@ public:
 	int weight() const;
 	class PolySet *convertToPolyset();
 	class DxfData *convertToDxfData() const;
-
+	void transform( const Transform3d &matrix );
 	int dim;
 	shared_ptr<CGAL_Nef_polyhedron2> p2;
 	shared_ptr<CGAL_Nef_polyhedron3> p3;
diff --git a/src/CGAL_Nef_polyhedron_DxfData.cc b/src/CGAL_Nef_polyhedron_DxfData.cc
index 0d0b8f0..0388fe5 100644
--- a/src/CGAL_Nef_polyhedron_DxfData.cc
+++ b/src/CGAL_Nef_polyhedron_DxfData.cc
@@ -29,7 +29,11 @@
 #include "CGAL_Nef_polyhedron.h"
 #include "cgal.h"
 #include "cgalutils.h"
-#include "svg.h"
+#include <boost/variant.hpp>
+#include "polyset.h"
+#include "dxftess.h"
+#include "CGALEvaluator.h"
+#include "Tree.h"
 
 #ifdef ENABLE_CGAL
 
@@ -89,4 +93,59 @@ std::string CGAL_Nef_polyhedron::dump() const
 		return std::string("Nef Polyhedron with dimension != 2 or 3");
 }
 
+
+void CGAL_Nef_polyhedron::transform( const Transform3d &matrix )
+{
+	if (!this->isNull()) {
+		if (this->dim == 2) {
+			// Unfortunately CGAL provides no transform method for CGAL_Nef_polyhedron2
+			// objects. So we convert in to our internal 2d data format, transform it,
+			// tesselate it and create a new CGAL_Nef_polyhedron2 from it.. What a hack!
+			Eigen::Matrix2f testmat;
+			testmat << matrix(0,0), matrix(0,1), matrix(1,0), matrix(1,1);
+			if (testmat.determinant() == 0) {
+				PRINT("Warning: Scaling a 2D object with 0 - removing object");
+				this->reset();
+				return;
+			}
+			else {
+				CGAL_Aff_transformation2 t(
+					matrix(0,0), matrix(0,1), matrix(0,3),
+					matrix(1,0), matrix(1,1), matrix(1,3), matrix(3,3));
+
+				DxfData *dd = this->convertToDxfData();
+				for (size_t i=0; i < dd->points.size(); i++) {
+					CGAL_Kernel2::Point_2 p = CGAL_Kernel2::Point_2(dd->points[i][0], dd->points[i][1]);
+					p = t.transform(p);
+					dd->points[i][0] = to_double(p.x());
+					dd->points[i][1] = to_double(p.y());
+				}
+
+				PolySet ps;
+				ps.is2d = true;
+				dxf_tesselate(&ps, *dd, 0, true, false, 0);
+
+				Tree nulltree;
+				CGALEvaluator tmpeval(nulltree);
+				CGAL_Nef_polyhedron N = tmpeval.evaluateCGALMesh(ps);
+				if ( N.p2 ) this->p2.reset( new CGAL_Nef_polyhedron2( *N.p2 ) );
+				delete dd;
+			}
+		}
+		else if (this->dim == 3) {
+			if (matrix.matrix().determinant() == 0) {
+				PRINT("Warning: Scaling a 3D object with 0 - removing object");
+				this->reset();
+			}
+			else {
+				CGAL_Aff_transformation t(
+					matrix(0,0), matrix(0,1), matrix(0,2), matrix(0,3),
+					matrix(1,0), matrix(1,1), matrix(1,2), matrix(1,3),
+					matrix(2,0), matrix(2,1), matrix(2,2), matrix(2,3), matrix(3,3));
+				this->p3->transform(t);
+			}
+		}
+	}
+}
+
 #endif // ENABLE_CGAL
diff --git a/src/Camera.h b/src/Camera.h
new file mode 100644
index 0000000..dfc71f8
--- /dev/null
+++ b/src/Camera.h
@@ -0,0 +1,80 @@
+#ifndef OPENSCAD_CAMERA_H_
+#define OPENSCAD_CAMERA_H_
+
+/*
+
+Camera
+
+For usage, see QGLView.cc, GLView.cc, export_png.cc, openscad.cc
+
+There are two different types of cameras represented in this class:
+
+*Gimbal camera - uses Euler Angles, object translation, and viewer distance
+*Vector camera - uses 'eye', 'center', and 'up' vectors ('lookat' style)
+
+They are not necessarily kept in sync. There are two modes of
+projection, Perspective and Orthogonal.
+
+*/
+
+#include <vector>
+#include <Eigen/Geometry>
+#include "rendersettings.h"
+
+class Camera
+{
+public:
+	enum CameraType { NONE, GIMBAL, VECTOR } type;
+	enum ProjectionType { ORTHOGONAL, PERSPECTIVE } projection;
+	Camera() {
+		type = Camera::NONE;
+		projection = Camera::PERSPECTIVE;
+	}
+	Camera( enum CameraType e )
+	{
+		type = e;
+		if ( e == Camera::GIMBAL ) {
+			object_trans << 0,0,0;
+			object_rot << 35,0,25;
+			viewer_distance = 500;
+		} else if ( e == Camera::VECTOR ) {
+			center << 0,0,0;
+			Eigen::Vector3d cameradir(1, 1, -0.5);
+			eye = center - 500 * cameradir;
+		}
+		pixel_width = RenderSettings::inst()->img_width;
+		pixel_height = RenderSettings::inst()->img_height;
+		projection = Camera::PERSPECTIVE;
+	}
+
+	void setup( std::vector<double> params ) {
+		if ( params.size() == 7 ) {
+			type = Camera::GIMBAL;
+			object_trans << params[0], params[1], params[2];
+			object_rot << params[3], params[4], params[5];
+			viewer_distance = params[6];
+		} else if ( params.size() == 6 ) {
+			type = Camera::VECTOR;
+			eye << params[0], params[1], params[2];
+			center << params[3], params[4], params[5];
+		} else {
+			assert( "Gimbal cam needs 7 numbers, Vector camera needs 6" );
+		}
+	}
+
+	// Vectorcam
+	Eigen::Vector3d eye;
+	Eigen::Vector3d center; // (aka 'target')
+	Eigen::Vector3d up; // not used currently
+
+	// Gimbalcam
+	Eigen::Vector3d object_trans;
+	Eigen::Vector3d object_rot;
+	double viewer_distance;
+
+	unsigned int pixel_width;
+	unsigned int pixel_height;
+};
+
+
+#endif
diff --git a/src/CocoaUtils.h b/src/CocoaUtils.h
new file mode 100644
index 0000000..ad5518b
--- /dev/null
+++ b/src/CocoaUtils.h
@@ -0,0 +1,13 @@
+#ifndef COCOAUTILS_H_
+#define COCOAUTILS_H_
+
+#include <string>
+
+class CocoaUtils
+{
+public:
+	static void endApplication();
+	static std::string documentsPath();
+};
+
+#endif
diff --git a/src/CocoaUtils.mm b/src/CocoaUtils.mm
new file mode 100644
index 0000000..295ceb9
--- /dev/null
+++ b/src/CocoaUtils.mm
@@ -0,0 +1,15 @@
+#include "CocoaUtils.h"
+#import <Foundation/Foundation.h>
+#include <stdio.h>
+
+void CocoaUtils::endApplication()
+{
+  [[NSNotificationCenter defaultCenter]
+    postNotificationName:@"NSApplicationWillTerminateNotification"
+                  object:nil];
+}
+
+std::string CocoaUtils::documentsPath()
+{
+  return std::string([[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] UTF8String]);
+}
diff --git a/src/CsgInfo.h b/src/CsgInfo.h
new file mode 100644
index 0000000..fe953b5
--- /dev/null
+++ b/src/CsgInfo.h
@@ -0,0 +1,92 @@
+#ifndef __CSGINFO_H__
+#define __CSGINFO_H__
+
+#include "OffscreenView.h"
+#include "csgterm.h"
+#include "Tree.h"
+#include "CGALEvaluator.h"
+#include "CSGTermEvaluator.h"
+#include "csgtermnormalizer.h"
+#include "rendersettings.h"
+#include "printutils.h"
+
+class CsgInfo
+{
+public:
+	CsgInfo()
+	{
+		root_chain = NULL;
+		highlights_chain = NULL;
+		background_chain = NULL;
+		glview = NULL;
+		progress_function = NULL;
+		normalizelimit = RenderSettings::inst()->openCSGTermLimit;
+	}
+	OffscreenView *glview;
+	shared_ptr<CSGTerm> root_norm_term;    // Normalized CSG products
+	class CSGChain *root_chain;
+	std::vector<shared_ptr<CSGTerm> > highlight_terms;
+	CSGChain *highlights_chain;
+	std::vector<shared_ptr<CSGTerm> > background_terms;
+	CSGChain *background_chain;
+	int normalizelimit;
+
+	void (*progress_function)();
+	void call_progress_function()
+	{
+		if (progress_function) progress_function();
+	}
+
+	bool compile_chains( const Tree &tree )
+	{
+		const AbstractNode *root_node = tree.root();
+		CGALEvaluator cgalevaluator(tree);
+		CSGTermEvaluator evaluator(tree, &cgalevaluator.psevaluator);
+		boost::shared_ptr<CSGTerm> root_raw_term = evaluator.evaluateCSGTerm( *root_node, this->highlight_terms, this->background_terms );
+
+		if (!root_raw_term) {
+			PRINT("Error: CSG generation failed! (no top level object found)");
+			call_progress_function();
+			return false;
+		}
+
+		PRINT("Compiling design (CSG Products normalization)...");
+		call_progress_function();
+		CSGTermNormalizer normalizer( normalizelimit );
+		this->root_norm_term = normalizer.normalize(root_raw_term);
+		if (this->root_norm_term) {
+			this->root_chain = new CSGChain();
+			this->root_chain->import(this->root_norm_term);
+			PRINTB("Normalized CSG tree has %d elements", int(this->root_chain->polysets.size()));
+		}
+		else {
+			this->root_chain = NULL;
+			PRINT("WARNING: CSG normalization resulted in an empty tree");
+			call_progress_function();
+		}
+
+		if (this->highlight_terms.size() > 0) {
+			PRINTB("Compiling highlights (%i CSG Trees)...", this->highlight_terms.size() );
+			call_progress_function();
+			this->highlights_chain = new CSGChain();
+			for (unsigned int i = 0; i < this->highlight_terms.size(); i++) {
+				this->highlight_terms[i] = normalizer.normalize(this->highlight_terms[i]);
+				this->highlights_chain->import(this->highlight_terms[i]);
+			}
+		}
+
+		if (this->background_terms.size() > 0) {
+			PRINTB("Compiling background (%i CSG Trees)...", this->background_terms.size());
+			call_progress_function();
+			this->background_chain = new CSGChain();
+			for (unsigned int i = 0; i < this->background_terms.size(); i++) {
+				this->background_terms[i] = normalizer.normalize(this->background_terms[i]);
+				this->background_chain->import(this->background_terms[i]);
+			}
+		}
+		return true;
+	}
+};
+
+#endif
+
diff --git a/src/GLView.cc b/src/GLView.cc
new file mode 100644
index 0000000..b4fb8d6
--- /dev/null
+++ b/src/GLView.cc
@@ -0,0 +1,477 @@
+#include "GLView.h"
+
+#include "stdio.h"
+#include "rendersettings.h"
+
+#ifdef _WIN32
+#include <GL/wglew.h>
+#elif !defined(__APPLE__)
+#include <GL/glxew.h>
+#endif
+
+#ifdef ENABLE_OPENCSG
+#include <opencsg.h>
+#endif
+
+GLView::GLView()
+{
+  showedges = false;
+  showfaces = true;
+  showaxes = false;
+  showcrosshairs = false;
+  renderer = NULL;
+  cam = Camera();
+  far_far_away = RenderSettings::inst()->far_gl_clip_limit;
+#ifdef ENABLE_OPENCSG
+  is_opencsg_capable = false;
+  has_shaders = false;
+  opencsg_support = true;
+  static int sId = 0;
+  this->opencsg_id = sId++;
+  for (int i = 0; i < 10; i++) this->shaderinfo[i] = 0;
+#endif
+}
+
+void GLView::setRenderer(Renderer* r)
+{
+  renderer = r;
+}
+
+void GLView::resizeGL(int w, int h)
+{
+#ifdef ENABLE_OPENCSG
+  shaderinfo[9] = w;
+  shaderinfo[10] = h;
+#endif
+  cam.pixel_width = w;
+  cam.pixel_height = h;
+  glViewport(0, 0, w, h);
+  w_h_ratio = sqrt((double)w / (double)h);
+}
+
+void GLView::setupGimbalCamPerspective()
+{
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glFrustum(-w_h_ratio, +w_h_ratio, -(1/w_h_ratio), +(1/w_h_ratio), +10.0, +far_far_away);
+  gluLookAt(0.0, -cam.viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
+}
+
+void GLView::setupGimbalCamOrtho(double distance, bool offset)
+{
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  if (offset) glTranslated(-0.8, -0.8, 0);
+  double l = distance/10;
+  glOrtho(-w_h_ratio*l, +w_h_ratio*l,
+      -(1/w_h_ratio)*l, +(1/w_h_ratio)*l,
+      -far_far_away, +far_far_away);
+  gluLookAt(0.0, -cam.viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
+}
+
+void GLView::setupVectorCamPerspective()
+{
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  double dist = (cam.center - cam.eye).norm();
+  gluPerspective(45, pow(w_h_ratio,2), 0.1*dist, 100*dist);
+}
+
+void GLView::setupVectorCamOrtho(bool offset)
+{
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  if (offset) glTranslated(-0.8, -0.8, 0);
+  double l = (cam.center - cam.eye).norm() / 10;
+  glOrtho(-pow(w_h_ratio,2)*l, +pow(w_h_ratio,2)*l,
+          -(1/pow(w_h_ratio,2))*l, +(1/pow(w_h_ratio,2))*l,
+          -far_far_away, +far_far_away);
+}
+
+void GLView::setCamera( Camera &cam )
+{
+  this->cam = cam;
+}
+
+void GLView::paintGL()
+{
+  if (cam.type == Camera::GIMBAL) gimbalCamPaintGL();
+  else if (cam.type == Camera::VECTOR) vectorCamPaintGL();
+  else if (cam.type == Camera::NONE) {
+    fprintf(stderr,"paintGL with null camera\n");
+  }
+}
+
+#ifdef ENABLE_OPENCSG
+void GLView::enable_opencsg_shaders()
+{
+  const char *openscad_disable_gl20_env = getenv("OPENSCAD_DISABLE_GL20");
+  if (openscad_disable_gl20_env && !strcmp(openscad_disable_gl20_env, "0")) {
+    openscad_disable_gl20_env = NULL;
+  }
+
+  // All OpenGL 2 contexts are OpenCSG capable
+  if (GLEW_VERSION_2_0) {
+    if (!openscad_disable_gl20_env) {
+      this->is_opencsg_capable = true;
+      this->has_shaders = true;
+    }
+  }
+
+  // If OpenGL < 2, check for extensions
+  else {
+    if (GLEW_ARB_framebuffer_object) this->is_opencsg_capable = true;
+    else if (GLEW_EXT_framebuffer_object && GLEW_EXT_packed_depth_stencil) {
+      this->is_opencsg_capable = true;
+    }
+#ifdef WIN32
+    else if (WGLEW_ARB_pbuffer && WGLEW_ARB_pixel_format) this->is_opencsg_capable = true;
+#elif !defined(__APPLE__)
+    else if (GLXEW_SGIX_pbuffer && GLXEW_SGIX_fbconfig) this->is_opencsg_capable = true;
+#endif
+  }
+
+  if (!GLEW_VERSION_2_0 || !this->is_opencsg_capable) {
+    display_opencsg_warning();
+  }
+
+  if (opencsg_support && this->has_shaders) {
+  /*
+    Uniforms:
+      1 color1 - face color
+      2 color2 - edge color
+      7 xscale
+      8 yscale
+
+    Attributes:
+      3 trig
+      4 pos_b
+      5 pos_c
+      6 mask
+
+    Other:
+      9 width
+      10 height
+
+    Outputs:
+      tp
+      tr
+      shading
+   */
+    const char *vs_source =
+      "uniform float xscale, yscale;\n"
+      "attribute vec3 pos_b, pos_c;\n"
+      "attribute vec3 trig, mask;\n"
+      "varying vec3 tp, tr;\n"
+      "varying float shading;\n"
+      "void main() {\n"
+      "  vec4 p0 = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
+      "  vec4 p1 = gl_ModelViewProjectionMatrix * vec4(pos_b, 1.0);\n"
+      "  vec4 p2 = gl_ModelViewProjectionMatrix * vec4(pos_c, 1.0);\n"
+      "  float a = distance(vec2(xscale*p1.x/p1.w, yscale*p1.y/p1.w), vec2(xscale*p2.x/p2.w, yscale*p2.y/p2.w));\n"
+      "  float b = distance(vec2(xscale*p0.x/p0.w, yscale*p0.y/p0.w), vec2(xscale*p1.x/p1.w, yscale*p1.y/p1.w));\n"
+      "  float c = distance(vec2(xscale*p0.x/p0.w, yscale*p0.y/p0.w), vec2(xscale*p2.x/p2.w, yscale*p2.y/p2.w));\n"
+      "  float s = (a + b + c) / 2.0;\n"
+      "  float A = sqrt(s*(s-a)*(s-b)*(s-c));\n"
+      "  float ha = 2.0*A/a;\n"
+      "  gl_Position = p0;\n"
+      "  tp = mask * ha;\n"
+      "  tr = trig;\n"
+      "  vec3 normal, lightDir;\n"
+      "  normal = normalize(gl_NormalMatrix * gl_Normal);\n"
+      "  lightDir = normalize(vec3(gl_LightSource[0].position));\n"
+      "  shading = abs(dot(normal, lightDir));\n"
+      "}\n";
+
+    /*
+      Inputs:
+        tp && tr - if any components of tp < tr, use color2 (edge color)
+        shading  - multiplied by color1. color2 is is without lighting
+		*/
+    const char *fs_source =
+      "uniform vec4 color1, color2;\n"
+      "varying vec3 tp, tr, tmp;\n"
+      "varying float shading;\n"
+      "void main() {\n"
+      "  gl_FragColor = vec4(color1.r * shading, color1.g * shading, color1.b * shading, color1.a);\n"
+      "  if (tp.x < tr.x || tp.y < tr.y || tp.z < tr.z)\n"
+      "    gl_FragColor = color2;\n"
+      "}\n";
+
+    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vs, 1, (const GLchar**)&vs_source, NULL);
+    glCompileShader(vs);
+
+    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fs, 1, (const GLchar**)&fs_source, NULL);
+    glCompileShader(fs);
+
+    GLuint edgeshader_prog = glCreateProgram();
+    glAttachShader(edgeshader_prog, vs);
+    glAttachShader(edgeshader_prog, fs);
+    glLinkProgram(edgeshader_prog);
+
+    shaderinfo[0] = edgeshader_prog;
+    shaderinfo[1] = glGetUniformLocation(edgeshader_prog, "color1");
+    shaderinfo[2] = glGetUniformLocation(edgeshader_prog, "color2");
+    shaderinfo[3] = glGetAttribLocation(edgeshader_prog, "trig");
+    shaderinfo[4] = glGetAttribLocation(edgeshader_prog, "pos_b");
+    shaderinfo[5] = glGetAttribLocation(edgeshader_prog, "pos_c");
+    shaderinfo[6] = glGetAttribLocation(edgeshader_prog, "mask");
+    shaderinfo[7] = glGetUniformLocation(edgeshader_prog, "xscale");
+    shaderinfo[8] = glGetUniformLocation(edgeshader_prog, "yscale");
+
+    GLenum err = glGetError();
+    if (err != GL_NO_ERROR) {
+      fprintf(stderr, "OpenGL Error: %s\n", gluErrorString(err));
+    }
+
+    GLint status;
+    glGetProgramiv(edgeshader_prog, GL_LINK_STATUS, &status);
+    if (status == GL_FALSE) {
+      int loglen;
+      char logbuffer[1000];
+      glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
+      fprintf(stderr, "OpenGL Program Linker Error:\n%.*s", loglen, logbuffer);
+    } else {
+      int loglen;
+      char logbuffer[1000];
+      glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
+      if (loglen > 0) {
+        fprintf(stderr, "OpenGL Program Link OK:\n%.*s", loglen, logbuffer);
+      }
+      glValidateProgram(edgeshader_prog);
+      glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
+      if (loglen > 0) {
+        fprintf(stderr, "OpenGL Program Validation results:\n%.*s", loglen, logbuffer);
+      }
+    }
+  }
+}
+#endif
+
+void GLView::initializeGL()
+{
+  glEnable(GL_DEPTH_TEST);
+  glDepthRange(-far_far_away, +far_far_away);
+
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
+  GLfloat light_position0[] = {-1.0, -1.0, +1.0, 0.0};
+  GLfloat light_position1[] = {+1.0, +1.0, -1.0, 0.0};
+
+  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
+  glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
+  glEnable(GL_LIGHT0);
+  glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
+  glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
+  glEnable(GL_LIGHT1);
+  glEnable(GL_LIGHTING);
+  glEnable(GL_NORMALIZE);
+
+  glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
+  glEnable(GL_COLOR_MATERIAL);
+#ifdef ENABLE_OPENCSG
+  enable_opencsg_shaders();
+#endif
+}
+
+void GLView::vectorCamPaintGL()
+{
+  glEnable(GL_LIGHTING);
+
+  if (cam.projection==Camera::ORTHOGONAL) setupVectorCamOrtho();
+  else setupVectorCamPerspective();
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  glClearColor(1.0f, 1.0f, 0.92f, 1.0f);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+  gluLookAt(cam.eye[0], cam.eye[1], cam.eye[2],
+            cam.center[0], cam.center[1], cam.center[2],
+            0.0, 0.0, 1.0);
+
+  // fixme - showcrosshairs doesnt work with vector camera
+  // if (showcrosshairs) GLView::showCrosshairs();
+
+  if (showaxes) GLView::showAxes();
+
+  glDepthFunc(GL_LESS);
+  glCullFace(GL_BACK);
+  glDisable(GL_CULL_FACE);
+
+  glLineWidth(2);
+  glColor3d(1.0, 0.0, 0.0);
+  //FIXME showSmallAxes wont work with vector camera
+  //if (showaxes) GLView::showSmallaxes();
+
+  if (this->renderer) {
+    this->renderer->draw(showfaces, showedges);
+  }
+}
+
+void GLView::gimbalCamPaintGL()
+{
+  glEnable(GL_LIGHTING);
+
+  if (cam.projection == Camera::ORTHOGONAL)
+    GLView::setupGimbalCamOrtho(cam.viewer_distance);
+  else
+    GLView::setupGimbalCamPerspective();
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  Color4f bgcol = RenderSettings::inst()->color(RenderSettings::BACKGROUND_COLOR);
+  glClearColor(bgcol[0], bgcol[1], bgcol[2], 1.0);
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+  glRotated(cam.object_rot.x(), 1.0, 0.0, 0.0);
+  glRotated(cam.object_rot.y(), 0.0, 1.0, 0.0);
+  glRotated(cam.object_rot.z(), 0.0, 0.0, 1.0);
+
+  if (showcrosshairs) GLView::showCrosshairs();
+
+  glTranslated(cam.object_trans.x(), cam.object_trans.y(), cam.object_trans.z() );
+
+  if (showaxes) GLView::showAxes();
+
+  glDepthFunc(GL_LESS);
+  glCullFace(GL_BACK);
+  glDisable(GL_CULL_FACE);
+  glLineWidth(2);
+  glColor3d(1.0, 0.0, 0.0);
+
+  if (this->renderer) {
+#if defined(ENABLE_MDI) && defined(ENABLE_OPENCSG)
+    // FIXME: This belongs in the OpenCSG renderer, but it doesn't know about this ID yet
+    OpenCSG::setContext(this->opencsg_id);
+#endif
+    this->renderer->draw(showfaces, showedges);
+	}
+  // Small axis cross in the lower left corner
+  if (showaxes) GLView::showSmallaxes();
+}
+
+void GLView::showSmallaxes()
+{
+  // Fixme - this doesnt work in Vector Camera mode
+
+  // Small axis cross in the lower left corner
+  glDepthFunc(GL_ALWAYS);
+
+  GLView::setupGimbalCamOrtho(1000,true);
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glRotated(cam.object_rot.x(), 1.0, 0.0, 0.0);
+  glRotated(cam.object_rot.y(), 0.0, 1.0, 0.0);
+  glRotated(cam.object_rot.z(), 0.0, 0.0, 1.0);
+
+  glLineWidth(1);
+  glBegin(GL_LINES);
+  glColor3d(1.0, 0.0, 0.0);
+  glVertex3d(0, 0, 0); glVertex3d(10, 0, 0);
+  glColor3d(0.0, 1.0, 0.0);
+  glVertex3d(0, 0, 0); glVertex3d(0, 10, 0);
+  glColor3d(0.0, 0.0, 1.0);
+  glVertex3d(0, 0, 0); glVertex3d(0, 0, 10);
+  glEnd();
+
+  GLdouble mat_model[16];
+  glGetDoublev(GL_MODELVIEW_MATRIX, mat_model);
+
+  GLdouble mat_proj[16];
+  glGetDoublev(GL_PROJECTION_MATRIX, mat_proj);
+
+  GLint viewport[4];
+  glGetIntegerv(GL_VIEWPORT, viewport);
+
+  GLdouble xlabel_x, xlabel_y, xlabel_z;
+  gluProject(12, 0, 0, mat_model, mat_proj, viewport, &xlabel_x, &xlabel_y, &xlabel_z);
+  xlabel_x = round(xlabel_x); xlabel_y = round(xlabel_y);
+
+  GLdouble ylabel_x, ylabel_y, ylabel_z;
+  gluProject(0, 12, 0, mat_model, mat_proj, viewport, &ylabel_x, &ylabel_y, &ylabel_z);
+  ylabel_x = round(ylabel_x); ylabel_y = round(ylabel_y);
+
+  GLdouble zlabel_x, zlabel_y, zlabel_z;
+  gluProject(0, 0, 12, mat_model, mat_proj, viewport, &zlabel_x, &zlabel_y, &zlabel_z);
+  zlabel_x = round(zlabel_x); zlabel_y = round(zlabel_y);
+
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glTranslated(-1, -1, 0);
+  glScaled(2.0/viewport[2], 2.0/viewport[3], 1);
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  // FIXME: This was an attempt to keep contrast with background, but is suboptimal
+  // (e.g. nearly invisible against a gray background).
+  //    int r,g,b;
+  //    r=g=b=0;
+  //    bgcol.getRgb(&r, &g, &b);
+  //    glColor3f((255.0f-r)/255.0f, (255.0f-g)/255.0f, (255.0f-b)/255.0f);
+  glColor3f(0.0f, 0.0f, 0.0f);
+  glBegin(GL_LINES);
+  // X Label
+  glVertex3d(xlabel_x-3, xlabel_y-3, 0); glVertex3d(xlabel_x+3, xlabel_y+3, 0);
+  glVertex3d(xlabel_x-3, xlabel_y+3, 0); glVertex3d(xlabel_x+3, xlabel_y-3, 0);
+  // Y Label
+  glVertex3d(ylabel_x-3, ylabel_y-3, 0); glVertex3d(ylabel_x+3, ylabel_y+3, 0);
+  glVertex3d(ylabel_x-3, ylabel_y+3, 0); glVertex3d(ylabel_x, ylabel_y, 0);
+  // Z Label
+  glVertex3d(zlabel_x-3, zlabel_y-3, 0); glVertex3d(zlabel_x+3, zlabel_y-3, 0);
+  glVertex3d(zlabel_x-3, zlabel_y+3, 0); glVertex3d(zlabel_x+3, zlabel_y+3, 0);
+  glVertex3d(zlabel_x-3, zlabel_y-3, 0); glVertex3d(zlabel_x+3, zlabel_y+3, 0);
+  // FIXME - depends on gimbal camera 'viewer distance'.. how to fix this
+  //         for VectorCamera?
+  glEnd();
+
+  //Restore perspective for next paint
+  if(cam.projection==Camera::PERSPECTIVE)
+    GLView::setupGimbalCamPerspective();
+}
+
+void GLView::showAxes()
+{
+  // FIXME: doesn't work under Vector Camera
+  // Large gray axis cross inline with the model
+  // FIXME: This is always gray - adjust color to keep contrast with background
+  glLineWidth(1);
+  glColor3d(0.5, 0.5, 0.5);
+  glBegin(GL_LINES);
+  double l = cam.viewer_distance/10;
+  glVertex3d(-l, 0, 0);
+  glVertex3d(+l, 0, 0);
+  glVertex3d(0, -l, 0);
+  glVertex3d(0, +l, 0);
+  glVertex3d(0, 0, -l);
+  glVertex3d(0, 0, +l);
+  glEnd();
+}
+
+void GLView::showCrosshairs()
+{
+	// FIXME: this might not work with Vector camera
+  // FIXME: Crosshairs and axes are lighted, this doesn't make sense and causes them
+  // to change color based on view orientation.
+  glLineWidth(3);
+  Color4f col = RenderSettings::inst()->color(RenderSettings::CROSSHAIR_COLOR);
+  glColor3f(col[0], col[1], col[2]);
+  glBegin(GL_LINES);
+  for (double xf = -1; xf <= +1; xf += 2)
+  for (double yf = -1; yf <= +1; yf += 2) {
+    double vd = cam.viewer_distance/20;
+    glVertex3d(-xf*vd, -yf*vd, -vd);
+    glVertex3d(+xf*vd, +yf*vd, +vd);
+  }
+  glEnd();
+}
+
diff --git a/src/GLView.h b/src/GLView.h
index 5552e4b..165c634 100644
--- a/src/GLView.h
+++ b/src/GLView.h
@@ -1,95 +1,81 @@
 #ifndef GLVIEW_H_
 #define GLVIEW_H_
 
-#include "system-gl.h"
-#include <QGLWidget>
-#include <QLabel>
+/* GLView: A basic OpenGL rectangle for rendering images.
 
-class GLView : public QGLWidget
-{
-	Q_OBJECT
-	Q_PROPERTY(bool showFaces READ showFaces WRITE setShowFaces);
-	Q_PROPERTY(bool showEdges READ showEdges WRITE setShowEdges);
-	Q_PROPERTY(bool showAxes READ showAxes WRITE setShowAxes);
-	Q_PROPERTY(bool showCrosshairs READ showCrosshairs WRITE setShowCrosshairs);
-	Q_PROPERTY(bool orthoMode READ orthoMode WRITE setOrthoMode);
+This class is inherited by:
 
-public:
-	GLView(QWidget *parent = NULL);
-	GLView(const QGLFormat & format, QWidget *parent = NULL);
-	void setRenderer(class Renderer* r);
-#ifdef ENABLE_OPENCSG
-	bool hasOpenCSGSupport() { return this->opencsg_support; }
-#endif
-	// Properties
-	bool showFaces() const { return this->showfaces; }
-	void setShowFaces(bool enabled) { this->showfaces = enabled; }
-	bool showEdges() const { return this->showedges; }
-	void setShowEdges(bool enabled) { this->showedges = enabled; }
-	bool showAxes() const { return this->showaxes; }
-	void setShowAxes(bool enabled) { this->showaxes = enabled; }
-	bool showCrosshairs() const { return this->showcrosshairs; }
-	void setShowCrosshairs(bool enabled) { this->showcrosshairs = enabled; }
-	bool orthoMode() const { return this->orthomode; }
-	void setOrthoMode(bool enabled) { this->orthomode = enabled; }
-	const QString &getRendererInfo() const { return this->rendererInfo; }
+*QGLview - for Qt GUI
+*OffscreenView - for offscreen rendering, in tests and from command-line
 
-public:
-	QLabel *statusLabel;
-	double object_rot_x;
-	double object_rot_y;
-	double object_rot_z;
-	double object_trans_x;
-	double object_trans_y;
-	double object_trans_z;
-	GLint shaderinfo[11];
+The view assumes either a Gimbal Camera (rotation,translation,distance)
+or Vector Camera (eye,center/target) is being used. See Camera.h. The
+cameras are not kept in sync.
 
-#ifdef ENABLE_OPENCSG
-	bool opencsg_support;
-	int opencsg_id;
+QGLView only uses GimbalCamera while OffscreenView can use either one.
+Some actions (showCrossHairs) only work properly on Gimbal Camera.
+
+*/
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <string>
+#ifndef _MSC_VER
+#include <stdint.h>
 #endif
+#include "system-gl.h"
+#include <iostream>
+#include "renderer.h"
+#include "Camera.h"
 
-private:
-	void init();
-	Renderer *renderer;
+class GLView
+{
+public:
+	GLView();
+	void setRenderer(Renderer* r);
 
-	QString rendererInfo;
+	void initializeGL();
+	void resizeGL(int w, int h);
+	virtual void paintGL();
 
-	bool showfaces;
-	bool showedges;
-	bool showaxes;
-	bool showcrosshairs;
-	bool orthomode;
+	void setCamera( Camera &cam );
 
-	double viewer_distance;
+	void setupGimbalCamPerspective();
+	void setupGimbalCamOrtho(double distance, bool offset=false);
+	void gimbalCamPaintGL();
 
-	double w_h_ratio;
+	void setupVectorCamPerspective();
+	void setupVectorCamOrtho(bool offset=false);
+	void vectorCamPaintGL();
 
-	bool mouse_drag_active;
-	QPoint last_mouse;
+	void showCrosshairs();
+	void showAxes();
+	void showSmallaxes();
 
-	void keyPressEvent(QKeyEvent *event);
-	void wheelEvent(QWheelEvent *event);
-	void mousePressEvent(QMouseEvent *event);
-	void mouseMoveEvent(QMouseEvent *event);
-	void mouseReleaseEvent(QMouseEvent *event);
+	virtual bool save(const char *filename) = 0;
+	virtual std::string getRendererInfo() const = 0;
 
-	void initializeGL();
-	void resizeGL(int w, int h);
-	void setupPerspective();
-	void setupOrtho(double distance,bool offset=false);
-	void paintGL();
-	void normalizeAngle(GLdouble& angle);
+	Renderer *renderer;
+	Camera cam;
+	double far_far_away;
+	size_t width;
+	size_t height;
+	double w_h_ratio;
+	bool orthomode;
+	bool showaxes;
+	bool showfaces;
+	bool showedges;
+	bool showcrosshairs;
 
 #ifdef ENABLE_OPENCSG
-  bool is_opencsg_capable;
-  bool has_shaders;
-private slots:
-	void display_opencsg_warning();
+	GLint shaderinfo[11];
+	bool is_opencsg_capable;
+	bool has_shaders;
+	void enable_opencsg_shaders();
+	virtual void display_opencsg_warning() = 0;
+	bool opencsg_support;
+	int opencsg_id;
 #endif
-
-signals:
-	void doAnimateUpdate();
 };
 
 #endif
diff --git a/src/MainWindow.h b/src/MainWindow.h
index a4835c2..8745b8b 100644
--- a/src/MainWindow.h
+++ b/src/MainWindow.h
@@ -74,7 +74,6 @@ private slots:
 private:
 	void openFile(const QString &filename);
 	void refreshDocument();
-	AbstractNode *find_root_tag(AbstractNode *n);
 	void updateTemporalVariables();
 	bool fileChangedOnDisk();
 	bool includesChanged();
@@ -91,6 +90,7 @@ private:
   class QMessageBox *openglbox;
 
 private slots:
+	void actionUpdateCheck();
 	void actionNew();
 	void actionOpen();
 	void actionOpenRecent();
diff --git a/src/MainWindow.ui b/src/MainWindow.ui
index f71ac96..8e995cd 100644
--- a/src/MainWindow.ui
+++ b/src/MainWindow.ui
@@ -38,7 +38,7 @@
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
-          <widget class="GLView" name="glview" native="true"/>
+          <widget class="QGLView" name="qglview" native="true"/>
           <widget class="QTextEdit" name="console">
            <property name="readOnly">
             <bool>true</bool>
@@ -223,6 +223,7 @@
     <addaction name="helpActionHomepage"/>
     <addaction name="helpActionManual"/>
     <addaction name="helpActionLibraryInfo"/>
+    <addaction name="appActionUpdateCheck"/>
    </widget>
    <addaction name="menu_File"/>
    <addaction name="menu_Edit"/>
@@ -611,6 +612,9 @@
    </property>
   </action>
   <action name="helpActionAbout">
+   <property name="enabled">
+    <bool>true</bool>
+   </property>
    <property name="text">
     <string>About</string>
    </property>
@@ -676,12 +680,20 @@
     <string>Library info</string>
    </property>
   </action>
+  <action name="appActionUpdateCheck">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>Check for Update..</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>GLView</class>
+   <class>QGLView</class>
    <extends>QWidget</extends>
-   <header>GLView.h</header>
+   <header>QGLView.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
diff --git a/src/OffscreenContext.h b/src/OffscreenContext.h
new file mode 100644
index 0000000..e74e104
--- /dev/null
+++ b/src/OffscreenContext.h
@@ -0,0 +1,19 @@
+#ifndef OFFSCREENCONTEXT_H_
+#define OFFSCREENCONTEXT_H_
+
+// Here we implement a 'portability' pattern but since we are mixing
+// Objective-C with C++, it is a bit different. The main struct
+// isn't defined in the header, but instead inside the source code files
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include "fbo.h"
+
+struct OffscreenContext *create_offscreen_context(int w, int h);
+bool teardown_offscreen_context(OffscreenContext *ctx);
+bool save_framebuffer(OffscreenContext *ctx, const char * filename);
+bool save_framebuffer(OffscreenContext *ctx, std::ostream &output);
+std::string offscreen_context_getinfo(OffscreenContext *ctx);
+
+#endif
diff --git a/src/OffscreenContextAll.hpp b/src/OffscreenContextAll.hpp
new file mode 100644
index 0000000..b845114
--- /dev/null
+++ b/src/OffscreenContextAll.hpp
@@ -0,0 +1,73 @@
+// Functions shared by OffscreenContext[platform].cc
+// #include this directly after definition of struct OffscreenContext.
+
+#include <vector>
+#include <ostream>
+
+void bind_offscreen_context(OffscreenContext *ctx)
+{
+	if (ctx) fbo_bind(ctx->fbo);
+}
+
+/*
+   Capture framebuffer from OpenGL and write it to the given filename as PNG.
+ */
+bool save_framebuffer(OffscreenContext *ctx, const char *filename)
+{
+	std::ofstream fstream(filename,std::ios::out|std::ios::binary);
+	if (!fstream.is_open()) {
+		std::cerr << "Can't open file " << filename << " for writing";
+		return false;
+	} else {
+		save_framebuffer(ctx, fstream);
+		fstream.close();
+	}
+	return true;
+}
+
+/*!
+  Capture framebuffer from OpenGL and write it to the given ostream.
+  Called by save_framebuffer() from platform-specific code.
+ */
+bool save_framebuffer_common(OffscreenContext *ctx, std::ostream &output)
+{
+	if (!ctx) return false;
+	int samplesPerPixel = 4; // R, G, B and A
+	std::vector<GLubyte> pixels(ctx->width * ctx->height * samplesPerPixel);
+	glReadPixels(0, 0, ctx->width, ctx->height, GL_RGBA, GL_UNSIGNED_BYTE, &pixels[0]);
+
+	// Flip it vertically - images read from OpenGL buffers are upside-down
+	int rowBytes = samplesPerPixel * ctx->width;
+
+	unsigned char *flippedBuffer = (unsigned char *)malloc(rowBytes * ctx->height);
+	if (!flippedBuffer) {
+		std::cerr << "Unable to allocate flipped buffer for corrected image.";
+		return 1;
+	}
+	flip_image(&pixels[0], flippedBuffer, samplesPerPixel, ctx->width, ctx->height);
+
+	bool writeok = write_png(output, flippedBuffer, ctx->width, ctx->height);
+
+	free(flippedBuffer);
+
+	return writeok;
+}
+
+//	Called by create_offscreen_context() from platform-specific code.
+OffscreenContext *create_offscreen_context_common(OffscreenContext *ctx)
+{
+	if (!ctx) return NULL;
+	GLenum err = glewInit(); // must come after Context creation and before FBO c$
+	if (GLEW_OK != err) {
+		std::cerr << "Unable to init GLEW: " << glewGetErrorString(err) << "\n";
+		return NULL;
+	}
+
+	ctx->fbo = fbo_new();
+	if (!fbo_init(ctx->fbo, ctx->width, ctx->height)) {
+		return NULL;
+	}
+
+	return ctx;
+}
+
diff --git a/src/OffscreenContextCGL.mm b/src/OffscreenContextCGL.mm
new file mode 100644
index 0000000..76738aa
--- /dev/null
+++ b/src/OffscreenContextCGL.mm
@@ -0,0 +1,144 @@
+#include "OffscreenContext.h"
+#include "imageutils.h"
+#include "fbo.h"
+#include <iostream>
+#include <sstream>
+
+#import <AppKit/AppKit.h>   // for NSOpenGL...
+#include <CoreServices/CoreServices.h>
+#include <sys/utsname.h>
+
+#define REPORTGLERROR(task) { GLenum tGLErr = glGetError(); if (tGLErr != GL_NO_ERROR) { std::cout << "OpenGL error " << tGLErr << " while " << task << "\n"; } }
+
+struct OffscreenContext
+{
+  NSOpenGLContext *openGLContext;
+  NSAutoreleasePool *pool;
+  int width;
+  int height;
+  fbo_t *fbo;
+};
+
+#include "OffscreenContextAll.hpp"
+
+std::string offscreen_context_getinfo(OffscreenContext *)
+{
+  std::stringstream out;
+
+  struct utsname name;
+  uname(&name);
+
+  SInt32 majorVersion,minorVersion,bugFixVersion;
+  
+  Gestalt(gestaltSystemVersionMajor, &majorVersion);
+  Gestalt(gestaltSystemVersionMinor, &minorVersion);
+  Gestalt(gestaltSystemVersionBugFix, &bugFixVersion);
+
+  const char *arch = "unknown";
+  if (sizeof(int*) == 4) arch = "32-bit";
+  else if (sizeof(int*) == 8) arch = "64-bit";
+
+  out << "GL context creator: Cocoa / CGL\n"
+      << "PNG generator: Core Foundation\n"
+      << "OS info: Mac OS X " << majorVersion << "." << minorVersion << "." << bugFixVersion << " (" << name.machine << " kernel)\n"
+      << "Machine: " << arch << "\n";
+  return out.str();
+}
+
+OffscreenContext *create_offscreen_context(int w, int h)
+{
+  OffscreenContext *ctx = new OffscreenContext;
+  ctx->width = w;
+  ctx->height = h;
+
+  ctx->pool = [NSAutoreleasePool new];
+
+  // Create an OpenGL context just so that OpenGL calls will work. 
+  // Will not be used for actual rendering.
+                                   
+  NSOpenGLPixelFormatAttribute attributes[] = {
+    NSOpenGLPFAPixelBuffer,
+    NSOpenGLPFANoRecovery,
+    NSOpenGLPFADepthSize, 24,
+    NSOpenGLPFAStencilSize, 8,
+// Took out the acceleration requirement to be able to run the tests
+// in a non-accelerated VM.
+// NSOpenGLPFAAccelerated,
+    (NSOpenGLPixelFormatAttribute) 0
+  };
+  NSOpenGLPixelFormat *pixFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:attributes] autorelease];
+
+  // Create and make current the OpenGL context to render with (with color and depth buffers)
+  ctx->openGLContext = [[NSOpenGLContext alloc] initWithFormat:pixFormat shareContext:nil];
+  if (!ctx->openGLContext) {
+    std::cerr << "Unable to create NSOpenGLContext\n";
+    return NULL;
+  }
+
+  [ctx->openGLContext makeCurrentContext];
+  
+  // glewInit must come after Context creation and before FBO calls.
+  GLenum err = glewInit();
+  if (GLEW_OK != err) {
+    std::cerr << "Unable to init GLEW: " << glewGetErrorString(err) << std::endl;
+    return NULL;
+  }
+  glew_dump();
+
+  ctx->fbo = fbo_new();
+  if (!fbo_init(ctx->fbo, w, h)) {
+    return NULL;
+  }
+
+  return ctx;
+}
+
+bool teardown_offscreen_context(OffscreenContext *ctx)
+{
+  fbo_unbind(ctx->fbo);
+  fbo_delete(ctx->fbo);
+
+  /*
+   * Cleanup
+   */
+  [ctx->openGLContext clearDrawable];
+  [ctx->openGLContext release];
+
+  [ctx->pool release];
+  return true;
+}
+
+/*!
+  Capture framebuffer from OpenGL and write it to the given ostream
+*/
+bool save_framebuffer(OffscreenContext *ctx, std::ostream &output)
+{
+  if (!ctx) return false;
+  // Read pixels from OpenGL
+  int samplesPerPixel = 4; // R, G, B and A
+  int rowBytes = samplesPerPixel * ctx->width;
+  unsigned char *bufferData = (unsigned char *)malloc(rowBytes * ctx->height);
+  if (!bufferData) {
+    std::cerr << "Unable to allocate buffer for image extraction.";
+    return 1;
+  }
+  glReadPixels(0, 0, ctx->width, ctx->height, GL_RGBA, GL_UNSIGNED_BYTE, 
+               bufferData);
+  REPORTGLERROR("reading pixels from framebuffer");
+  
+  // Flip it vertically - images read from OpenGL buffers are upside-down
+  unsigned char *flippedBuffer = (unsigned char *)malloc(rowBytes * ctx->height);
+  if (!flippedBuffer) {
+    std::cout << "Unable to allocate flipped buffer for corrected image.";
+    return 1;
+  }
+  flip_image(bufferData, flippedBuffer, samplesPerPixel, ctx->width, ctx->height);
+
+  bool writeok = write_png(output, flippedBuffer, ctx->width, ctx->height);
+
+  free(flippedBuffer);
+  free(bufferData);
+
+  return writeok;
+}
+
diff --git a/src/OffscreenContextGLX.cc b/src/OffscreenContextGLX.cc
new file mode 100644
index 0000000..e76cae8
--- /dev/null
+++ b/src/OffscreenContextGLX.cc
@@ -0,0 +1,293 @@
+/*
+
+Create an OpenGL context without creating an OpenGL Window. for Linux.
+
+See also
+
+glxgears.c by Brian Paul from mesa-demos (mesa3d.org)
+http://cgit.freedesktop.org/mesa/demos/tree/src/xdemos?id=mesa-demos-8.0.1
+http://www.opengl.org/sdk/docs/man/xhtml/glXIntro.xml
+http://www.mesa3d.org/brianp/sig97/offscrn.htm
+http://glprogramming.com/blue/ch07.html
+OffscreenContext.mm (Mac OSX version)
+
+*/
+
+/*
+ * Some portions of the code below are:
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * 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, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * 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
+ * BRIAN PAUL 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.
+ */
+
+#include "OffscreenContext.h"
+#include "printutils.h"
+#include "imageutils.h"
+#include "system-gl.h"
+#include "fbo.h"
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+#include <assert.h>
+#include <sstream>
+
+#include <sys/utsname.h> // for uname
+
+using namespace std;
+
+struct OffscreenContext
+{
+	GLXContext openGLContext;
+	Display *xdisplay;
+	Window xwindow;
+	int width;
+	int height;
+	fbo_t *fbo;
+};
+
+#include "OffscreenContextAll.hpp"
+
+void offscreen_context_init(OffscreenContext &ctx, int width, int height)
+{
+	ctx.width = width;
+	ctx.height = height;
+	ctx.openGLContext = NULL;
+	ctx.xdisplay = NULL;
+	ctx.xwindow = (Window)NULL;
+	ctx.fbo = NULL;
+}
+
+string get_os_info()
+{
+	struct utsname u;
+	stringstream out;
+
+	if (uname(&u) < 0)
+		out << "OS info: unknown, uname() error\n";
+	else {
+		out << "OS info: "
+		    << u.sysname << " "
+		    << u.release << " "
+		    << u.version << "\n";
+		out << "Machine: " << u.machine;
+	}
+	return out.str();
+}
+
+string offscreen_context_getinfo(OffscreenContext *ctx)
+{
+	assert(ctx);
+
+	if (!ctx->xdisplay)
+		return string("No GL Context initialized. No information to report\n");
+
+	int major, minor;
+	glXQueryVersion(ctx->xdisplay, &major, &minor);
+
+	stringstream out;
+	out << "GL context creator: GLX\n"
+	    << "PNG generator: lodepng\n"
+	    << "GLX version: " << major << "." << minor << "\n"
+	    << get_os_info();
+
+	return out.str();
+}
+
+static XErrorHandler original_xlib_handler = (XErrorHandler) NULL;
+static bool XCreateWindow_failed = false;
+static int XCreateWindow_error(Display *dpy, XErrorEvent *event)
+{
+	cerr << "XCreateWindow failed: XID: " << event->resourceid
+	     << " request: " << (int)event->request_code
+	     << " minor: " << (int)event->minor_code << "\n";
+	char description[1024];
+	XGetErrorText( dpy, event->error_code, description, 1023 );
+	cerr << " error message: " << description << "\n";
+	XCreateWindow_failed = true;
+	return 0;
+}
+
+bool create_glx_dummy_window(OffscreenContext &ctx)
+{
+/*
+   create a dummy X window without showing it. (without 'mapping' it)
+   and save information to the ctx.
+
+   This purposely does not use glxCreateWindow, to avoid crashes,
+   "failed to create drawable" errors, and Mesa "WARNING: Application calling 
+   GLX 1.3 function when GLX 1.3 is not supported! This is an application bug!"
+
+   This function will alter ctx.openGLContext and ctx.xwindow if successfull
+ */
+
+	int attributes[] = {
+		GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT, //support all 3, for OpenCSG
+		GLX_RENDER_TYPE,   GLX_RGBA_BIT,
+		GLX_RED_SIZE, 8,
+		GLX_GREEN_SIZE, 8,
+		GLX_BLUE_SIZE, 8,
+		GLX_ALPHA_SIZE, 8,
+		GLX_DEPTH_SIZE, 24, // depth-stencil for OpenCSG
+		GLX_STENCIL_SIZE, 8,
+		GLX_DOUBLEBUFFER, True,
+		None
+	};
+
+	Display *dpy = ctx.xdisplay;
+
+	int num_returned = 0;
+	GLXFBConfig *fbconfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy), attributes, &num_returned );
+	if ( fbconfigs == NULL ) {
+		cerr << "glXChooseFBConfig failed\n";
+		return false;
+	}
+
+	XVisualInfo *visinfo = glXGetVisualFromFBConfig( dpy, fbconfigs[0] );
+	if ( visinfo == NULL ) {
+		cerr << "glXGetVisualFromFBConfig failed\n";
+		XFree( fbconfigs );
+		return false;
+	}
+
+	// can't depend on xWin==NULL at failure. use a custom Xlib error handler instead.
+	original_xlib_handler = XSetErrorHandler( XCreateWindow_error );
+
+	Window root = DefaultRootWindow( dpy );
+	XSetWindowAttributes xwin_attr;
+	int width = ctx.width;
+	int height = ctx.height;
+	xwin_attr.background_pixmap = None;
+	xwin_attr.background_pixel = 0;
+	xwin_attr.border_pixel = 0;
+	xwin_attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
+	xwin_attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+	unsigned long int mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+	Window xWin = XCreateWindow( dpy, root, 0, 0, width, height,
+			0, visinfo->depth, InputOutput,
+			visinfo->visual, mask, &xwin_attr );
+
+	// Window xWin = XCreateSimpleWindow( dpy, DefaultRootWindow(dpy), 0,0,42,42, 0,0,0 );
+
+	XSync( dpy, false );
+	if ( XCreateWindow_failed ) {
+		XFree( visinfo );
+		XFree( fbconfigs );
+		return false;
+	}
+	XSetErrorHandler( original_xlib_handler );
+
+	// Most programs would call XMapWindow here. But we don't, to keep the window hidden
+	// XMapWindow( dpy, xWin );
+
+	GLXContext context = glXCreateNewContext( dpy, fbconfigs[0], GLX_RGBA_TYPE, NULL, True );
+	if ( context == NULL ) {
+		cerr << "glXCreateNewContext failed\n";
+		XDestroyWindow( dpy, xWin );
+		XFree( visinfo );
+		XFree( fbconfigs );
+		return false;
+	}
+
+	//GLXWindow glxWin = glXCreateWindow( dpy, fbconfigs[0], xWin, NULL );
+
+	if (!glXMakeContextCurrent( dpy, xWin, xWin, context )) {
+		//if (!glXMakeContextCurrent( dpy, glxWin, glxWin, context )) {
+		cerr << "glXMakeContextCurrent failed\n";
+		glXDestroyContext( dpy, context );
+		XDestroyWindow( dpy, xWin );
+		XFree( visinfo );
+		XFree( fbconfigs );
+		return false;
+	}
+
+	ctx.openGLContext = context;
+	ctx.xwindow = xWin;
+
+	XFree( visinfo );
+	XFree( fbconfigs );
+
+	return true;
+	}
+
+	Bool create_glx_dummy_context(OffscreenContext &ctx);
+
+	OffscreenContext *create_offscreen_context(int w, int h)
+	{
+		OffscreenContext *ctx = new OffscreenContext;
+		offscreen_context_init( *ctx, w, h );
+
+		// before an FBO can be setup, a GLX context must be created
+		// this call alters ctx->xDisplay and ctx->openGLContext 
+		//  and ctx->xwindow if successfull
+		if (!create_glx_dummy_context( *ctx )) {
+			return NULL;
+		}
+
+		return create_offscreen_context_common( ctx );
+	}
+
+	bool teardown_offscreen_context(OffscreenContext *ctx)
+	{
+		if (ctx) {
+			fbo_unbind(ctx->fbo);
+			fbo_delete(ctx->fbo);
+			XDestroyWindow( ctx->xdisplay, ctx->xwindow );
+			glXDestroyContext( ctx->xdisplay, ctx->openGLContext );
+			XCloseDisplay( ctx->xdisplay );
+			return true;
+		}
+		return false;
+	}
+
+	bool save_framebuffer(OffscreenContext *ctx, std::ostream &output)
+	{
+		glXSwapBuffers(ctx->xdisplay, ctx->xwindow);
+		return save_framebuffer_common(ctx, output);
+	}
+
+#pragma GCC diagnostic ignored "-Waddress"
+	Bool create_glx_dummy_context(OffscreenContext &ctx)
+	{
+		// This will alter ctx.openGLContext and ctx.xdisplay and ctx.xwindow if successfull
+		int major;
+		int minor;
+		Bool result = False;
+
+		ctx.xdisplay = XOpenDisplay( NULL );
+		if ( ctx.xdisplay == NULL ) {
+			cerr << "Unable to open a connection to the X server\n";
+			return False;
+		}
+
+		// glxQueryVersion is not always reliable. Use it, but then
+		// also check to see if GLX 1.3 functions exist
+
+		glXQueryVersion(ctx.xdisplay, &major, &minor);
+		if ( major==1 && minor<=2 && glXGetVisualFromFBConfig==NULL ) {
+			cerr << "Error: GLX version 1.3 functions missing. "
+				<< "Your GLX version: " << major << "." << minor << endl;
+		} else {
+			result = create_glx_dummy_window(ctx);
+		}
+
+		if (!result) XCloseDisplay( ctx.xdisplay );
+		return result;
+	}
+
diff --git a/src/OffscreenContextWGL.cc b/src/OffscreenContextWGL.cc
new file mode 100644
index 0000000..0ccd68d
--- /dev/null
+++ b/src/OffscreenContextWGL.cc
@@ -0,0 +1,214 @@
+/*
+
+Create an OpenGL context without creating an OpenGL Window. for Windows.
+
+For more info:
+
+   http://www.nullterminator.net/opengl32.html by Blaine Hodge 
+   http://msdn.microsoft.com/en-us/library/ee418815(v=vs.85).aspx
+   http://www.cprogramming.com/tutorial/wgl_wiggle_functions.html by RoD
+    ( which includes robot.cc by Steven Billington )
+   http://blogs.msdn.com/b/oldnewthing/archive/2006/12/04/1205831.aspx by Tom
+*/
+
+#include <windows.h>
+#include <vector>
+
+#include "OffscreenContext.h"
+#include "printutils.h"
+#include "imageutils.h"
+#include "system-gl.h"
+#include "fbo.h"
+
+#include <GL/gl.h> // must be included after glew.h
+
+#include <map>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+struct OffscreenContext
+{
+  HWND window;
+  HDC dev_context;
+  HGLRC openGLContext;
+  int width;
+  int height;
+  fbo_t *fbo;
+};
+
+#include "OffscreenContextAll.hpp"
+
+void offscreen_context_init(OffscreenContext &ctx, int width, int height)
+{
+  ctx.window = (HWND)NULL;
+  ctx.dev_context = (HDC)NULL;
+  ctx.openGLContext = (HGLRC)NULL;
+  ctx.width = width;
+  ctx.height = height;
+  ctx.fbo = NULL;
+}
+
+string get_os_info()
+{
+  OSVERSIONINFO osvi;
+
+  ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
+  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+  GetVersionEx(&osvi);
+
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  map<WORD,const char*> archs;
+  archs[PROCESSOR_ARCHITECTURE_AMD64] = "amd64";
+  archs[PROCESSOR_ARCHITECTURE_IA64] = "itanium";
+  archs[PROCESSOR_ARCHITECTURE_INTEL] = "x86";
+  archs[PROCESSOR_ARCHITECTURE_UNKNOWN] = "unknown";
+
+  stringstream out;
+  out << "OS info: "
+      << "Microsoft(TM) Windows(TM) " << osvi.dwMajorVersion << " "
+      << osvi.dwMinorVersion << " " << osvi.dwBuildNumber << " "
+      << osvi.szCSDVersion;
+  if (archs.find(si.wProcessorArchitecture) != archs.end()) 
+    out << " " << archs[si.wProcessorArchitecture];
+  out << "\n";
+
+  out << "Machine: " << si.dwProcessorType;
+
+  return out.str();
+}
+
+string offscreen_context_getinfo(OffscreenContext *ctx)
+{
+  // should probably get some info from WGL context here?
+  stringstream out;
+  out << "GL context creator: WGL\n"
+      << "PNG generator: lodepng\n"
+      << get_os_info();
+  return out.str();
+}
+
+LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) 
+{
+  return DefWindowProc( hwnd, message, wparam, lparam );
+}
+
+bool create_wgl_dummy_context(OffscreenContext &ctx)
+{
+  // this function alters ctx->window and ctx->openGLContext 
+  //  and ctx->dev_context if successfull
+
+  // create window
+
+  HINSTANCE inst = GetModuleHandle(0);
+  WNDCLASS wc;
+  ZeroMemory( &wc, sizeof( wc ) );
+  wc.style = CS_OWNDC;
+  wc.lpfnWndProc = WndProc;
+  wc.hInstance = inst;
+  wc.lpszClassName = (LPCWSTR)"OpenSCAD";
+  RegisterClass( &wc );
+
+  HWND window = CreateWindow( (LPCWSTR)"OpenSCAD", (LPCWSTR)"OpenSCAD",
+    WS_CAPTION | WS_POPUPWINDOW,  //| WS_VISIBLE,
+    0, 0, ctx.width, ctx.height, NULL, NULL, inst, NULL );
+
+  if ( window==NULL ) {
+    cerr << "MS GDI - CreateWindow failed\n";
+    return false;
+  }
+
+  // create WGL context, make current
+
+  PIXELFORMATDESCRIPTOR pixformat;
+  int chosenformat;
+  HDC dev_context = GetDC( window );
+  if ( dev_context == NULL ) {
+    cerr << "MS GDI - GetDC failed\n";
+    return false;
+  }
+
+  ZeroMemory( &pixformat, sizeof( pixformat ) );
+  pixformat.nSize = sizeof( pixformat );
+  pixformat.nVersion = 1;
+  pixformat.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+  pixformat.iPixelType = PFD_TYPE_RGBA;
+  pixformat.cGreenBits = 8;
+  pixformat.cRedBits = 8;
+  pixformat.cBlueBits = 8;
+  pixformat.cAlphaBits = 8;
+  pixformat.cDepthBits = 24;
+  pixformat.cStencilBits = 8;
+
+  chosenformat = ChoosePixelFormat( dev_context, &pixformat );
+  if (chosenformat==0) {
+    cerr << "MS GDI - ChoosePixelFormat failed\n";
+    return false;
+  }
+
+  bool spfok = SetPixelFormat( dev_context, chosenformat, &pixformat );
+  if (!spfok) {
+    cerr << "MS GDI - SetPixelFormat failed\n";
+    return false;
+  }
+
+  HGLRC gl_render_context = wglCreateContext( dev_context );
+  if ( gl_render_context == NULL ) {
+      cerr << "MS WGL - wglCreateContext failed\n";
+      ReleaseDC( ctx.window, ctx.dev_context );
+      return false;
+  }
+
+  bool mcok = wglMakeCurrent( dev_context, gl_render_context );
+  if (!mcok) {
+    cerr << "MS WGL - wglMakeCurrent failed\n";
+    return false;
+  }
+
+  ctx.window = window;
+  ctx.dev_context = dev_context;
+  ctx.openGLContext = gl_render_context;
+
+  return true;
+}
+
+
+OffscreenContext *create_offscreen_context(int w, int h)
+{
+  OffscreenContext *ctx = new OffscreenContext;
+  offscreen_context_init( *ctx, w, h );
+
+  // Before an FBO can be setup, a WGL context must be created. 
+  // This call alters ctx->window and ctx->openGLContext 
+  //  and ctx->dev_context if successfull
+  if (!create_wgl_dummy_context( *ctx )) {
+    return NULL;
+  }
+
+  return create_offscreen_context_common( ctx );
+}
+
+bool teardown_offscreen_context(OffscreenContext *ctx)
+{
+  if (ctx) {
+    fbo_unbind(ctx->fbo);
+    fbo_delete(ctx->fbo);
+
+    wglMakeCurrent( NULL, NULL );
+    wglDeleteContext( ctx->openGLContext );
+    ReleaseDC( ctx->window, ctx->dev_context );
+
+    return true;
+  }
+  return false;
+}
+
+bool save_framebuffer(OffscreenContext *ctx, std::ostream &output)
+{
+  if (!ctx) return false;
+  wglSwapLayerBuffers( ctx->dev_context, WGL_SWAP_MAIN_PLANE );
+  return save_framebuffer_common( ctx, output );
+}
+
diff --git a/src/OffscreenView.cc b/src/OffscreenView.cc
new file mode 100644
index 0000000..2186eb1
--- /dev/null
+++ b/src/OffscreenView.cc
@@ -0,0 +1,49 @@
+#include <GL/glew.h>
+#include "OffscreenView.h"
+#include "system-gl.h"
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <cstdlib>
+#include <sstream>
+#include "printutils.h"
+
+OffscreenView::OffscreenView(size_t width, size_t height)
+{
+  this->ctx = create_offscreen_context(width, height);
+  if ( this->ctx == NULL ) throw -1;
+  GLView::initializeGL();
+  GLView::resizeGL(width, height);
+}
+
+OffscreenView::~OffscreenView()
+{
+  teardown_offscreen_context(this->ctx);
+}
+
+#ifdef ENABLE_OPENCSG
+void OffscreenView::display_opencsg_warning()
+{
+  PRINT("OpenSCAD recommended OpenGL version is 2.0.");
+}
+#endif
+
+bool OffscreenView::save(const char *filename)
+{
+  return save_framebuffer(this->ctx, filename);
+}
+
+bool OffscreenView::save(std::ostream &output)
+{
+  return save_framebuffer(this->ctx, output);
+}
+
+std::string OffscreenView::getRendererInfo() const
+{
+  std::stringstream out;
+
+  out << glew_dump()
+      << offscreen_context_getinfo(this->ctx);
+
+  return out.str();
+}
diff --git a/src/OffscreenView.h b/src/OffscreenView.h
new file mode 100644
index 0000000..8a3daaf
--- /dev/null
+++ b/src/OffscreenView.h
@@ -0,0 +1,31 @@
+#ifndef OFFSCREENVIEW_H_
+#define OFFSCREENVIEW_H_
+
+#include "OffscreenContext.h"
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <string>
+#ifndef _MSC_VER
+#include <stdint.h>
+#endif
+#include "system-gl.h"
+#include <iostream>
+#include "GLView.h"
+
+class OffscreenView : public GLView
+{
+public:
+	OffscreenView(size_t width, size_t height);
+	~OffscreenView();
+	bool save(std::ostream &output);
+	OffscreenContext *ctx;
+
+	// overrides
+	bool save(const char *filename);
+	std::string getRendererInfo() const;
+#ifdef ENABLE_OPENCSG
+	void display_opencsg_warning();
+#endif
+};
+
+#endif
diff --git a/src/PolySetCGALEvaluator.cc b/src/PolySetCGALEvaluator.cc
index be8ecc0..5976daf 100644
--- a/src/PolySetCGALEvaluator.cc
+++ b/src/PolySetCGALEvaluator.cc
@@ -20,105 +20,6 @@
 #include <boost/foreach.hpp>
 #include <vector>
 
-/*
-
-ZRemover
-
-This class converts one or more already 'flat' Nef3 polyhedra into a Nef2
-polyhedron by stripping off the 'z' coordinates from the vertices. The
-resulting Nef2 poly is accumulated in the 'output_nefpoly2d' member variable.
-
-The 'z' coordinates will either be all 0s, for an xy-plane intersected Nef3,
-or, they will be a mixture of -eps and +eps, for a thin-box intersected Nef3.
-
-Notes on CGAL's Nef Polyhedron2:
-
-1. The 'mark' on a 2d Nef face is important when doing unions/intersections.
- If the 'mark' of a face is wrong the resulting nef2 poly will be unexpected.
-2. The 'mark' can be dependent on the points fed to the Nef2 constructor.
- This is why we iterate through the 3d faces using the halfedge cycle
- source()->target() instead of the ordinary source()->source(). The
- the latter can generate sequences of points that will fail the
- the CGAL::is_simple_2() test, resulting in improperly marked nef2 polys.
-3. 3d facets have 'two sides'. we throw out the 'down' side to prevent dups.
-
-The class uses the 'visitor' pattern from the CGAL manual. See also
-http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3/Chapter_main.html
-http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3_ref/Class_Nef_polyhedron3.html
-OGL_helper.h
-*/
-
-class ZRemover {
-public:
-	logstream log;
-	CGAL_Nef_polyhedron2::Boundary boundary;
-	shared_ptr<CGAL_Nef_polyhedron2> tmpnef2d;
-	shared_ptr<CGAL_Nef_polyhedron2> output_nefpoly2d;
-	CGAL::Direction_3<CGAL_Kernel3> up;
-	ZRemover()
-	{
-		output_nefpoly2d.reset( new CGAL_Nef_polyhedron2() );
-		boundary = CGAL_Nef_polyhedron2::INCLUDED;
-		up = CGAL::Direction_3<CGAL_Kernel3>(0,0,1);
-		log = logstream(5);
-	}
-	void visit( CGAL_Nef_polyhedron3::Vertex_const_handle ) {}
-	void visit( CGAL_Nef_polyhedron3::Halfedge_const_handle ) {}
-	void visit( CGAL_Nef_polyhedron3::SHalfedge_const_handle ) {}
-	void visit( CGAL_Nef_polyhedron3::SHalfloop_const_handle ) {}
-	void visit( CGAL_Nef_polyhedron3::SFace_const_handle ) {}
-	void visit( CGAL_Nef_polyhedron3::Halffacet_const_handle hfacet ) {
-		log << " <!-- Halffacet visit. Mark: " << hfacet->mark() << " -->\n";
-		if ( hfacet->plane().orthogonal_direction() != this->up ) {
-			log << "  <!-- down-facing half-facet. skipping -->\n";
-			log << " <!-- Halffacet visit end-->\n";
-			return;
-		}
-
-		// possible optimization - throw out facets that are 'side facets' between
-		// the top & bottom of the big thin box. (i.e. mixture of z=-eps and z=eps)
-
-		CGAL_Nef_polyhedron3::Halffacet_cycle_const_iterator fci;
-		int contour_counter = 0;
-		CGAL_forall_facet_cycles_of( fci, hfacet ) {
-			if ( fci.is_shalfedge() ) {
-				CGAL_Nef_polyhedron3::SHalfedge_around_facet_const_circulator c1(fci), cend(c1);
-				std::vector<CGAL_Nef_polyhedron2::Explorer::Point> contour;
-				CGAL_For_all( c1, cend ) {
-					CGAL_Nef_polyhedron3::Point_3 point3d = c1->source()->target()->point();
-					CGAL_Nef_polyhedron2::Explorer::Point point2d(CGAL::to_double(point3d.x()),
-																												CGAL::to_double(point3d.y()));
-					contour.push_back( point2d );
-				}
-
-				if (contour.size()==0) continue;
-
-				log << " <!-- is_simple_2:" << CGAL::is_simple_2( contour.begin(), contour.end() ) << " --> \n";
-
-				tmpnef2d.reset( new CGAL_Nef_polyhedron2( contour.begin(), contour.end(), boundary ) );
-
-				if ( contour_counter == 0 ) {
-					log << " <!-- contour is a body. make union(). " << contour.size() << " points. -->\n" ;
-					*(output_nefpoly2d) += *(tmpnef2d);
-				} else {
-					log << " <!-- contour is a hole. make intersection(). " << contour.size() << " points. -->\n";
-					*(output_nefpoly2d) *= *(tmpnef2d);
-				}
-
-				log << "\n<!-- ======== output tmp nef: ==== -->\n"
-					<< OpenSCAD::dump_svg( *tmpnef2d ) << "\n"
-					<< "\n<!-- ======== output accumulator: ==== -->\n"
-					<< OpenSCAD::dump_svg( *output_nefpoly2d ) << "\n";
-
-				contour_counter++;
-			} else {
-				log << " <!-- trivial facet cycle skipped -->\n";
-			}
-		} // next facet cycle (i.e. next contour)
-		log << " <!-- Halffacet visit end -->\n";
-	} // visit()
-};
-
 PolySetCGALEvaluator::PolySetCGALEvaluator(CGALEvaluator &cgalevaluator)
 	: PolySetEvaluator(cgalevaluator.getTree()), cgalevaluator(cgalevaluator)
 {
@@ -187,24 +88,23 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
 			return NULL;
 		}
 
-		// remove z coordinates to make CGAL_Nef_polyhedron2
 		log << OpenSCAD::svg_header( 480, 100000 ) << "\n";
 		try {
-			ZRemover zremover;
-			CGAL_Nef_polyhedron3::Volume_const_iterator i;
-			CGAL_Nef_polyhedron3::Shell_entry_const_iterator j;
-			CGAL_Nef_polyhedron3::SFace_const_handle sface_handle;
-			for ( i = sum.p3->volumes_begin(); i != sum.p3->volumes_end(); ++i ) {
-				log << "<!-- volume. mark: " << i->mark() << " -->\n";
-				for ( j = i->shells_begin(); j != i->shells_end(); ++j ) {
-					log << "<!-- shell. mark: " << i->mark() << " -->\n";
-					sface_handle = CGAL_Nef_polyhedron3::SFace_const_handle( j );
-					sum.p3->visit_shell_objects( sface_handle , zremover );
-					log << "<!-- shell. end. -->\n";
-				}
-				log << "<!-- volume end. -->\n";
-			}
-			nef_poly.p2 = zremover.output_nefpoly2d;
+      ZRemover zremover;
+      CGAL_Nef_polyhedron3::Volume_const_iterator i;
+      CGAL_Nef_polyhedron3::Shell_entry_const_iterator j;
+      CGAL_Nef_polyhedron3::SFace_const_handle sface_handle;
+      for ( i = sum.p3->volumes_begin(); i != sum.p3->volumes_end(); ++i ) {
+        log << "<!-- volume. mark: " << i->mark() << " -->\n";
+        for ( j = i->shells_begin(); j != i->shells_end(); ++j ) {
+          log << "<!-- shell. mark: " << i->mark() << " -->\n";
+          sface_handle = CGAL_Nef_polyhedron3::SFace_const_handle( j );
+          sum.p3->visit_shell_objects( sface_handle , zremover );
+          log << "<!-- shell. end. -->\n";
+        }
+        log << "<!-- volume end. -->\n";
+      }
+      nef_poly.p2 = zremover.output_nefpoly2d;
 		}	catch (const CGAL::Failure_exception &e) {
 			PRINTB("CGAL error in projection node while flattening: %s", e.what());
 		}
diff --git a/src/Preferences.cc b/src/Preferences.cc
index ec66094..0f3115e 100644
--- a/src/Preferences.cc
+++ b/src/Preferences.cc
@@ -26,10 +26,13 @@
 
 #include "Preferences.h"
 
+#include <QMessageBox>
 #include <QFontDatabase>
 #include <QKeyEvent>
 #include <QSettings>
+#include <QStatusBar>
 #include "PolySetCache.h"
+#include "AutoUpdater.h"
 #ifdef ENABLE_CGAL
 #include "CGALCache.h"
 #endif
@@ -80,7 +83,7 @@ Preferences::Preferences(QWidget *parent) : QMainWindow(parent)
 #ifdef ENABLE_CGAL
 	this->defaultmap["advanced/cgalCacheSize"] = uint(CGALCache::instance()->maxSize());
 #endif
-	this->defaultmap["advanced/openCSGLimit"] = 2000;
+	this->defaultmap["advanced/openCSGLimit"] = RenderSettings::inst()->openCSGTermLimit;
 	this->defaultmap["advanced/forceGoldfeather"] = false;
 
 
@@ -88,6 +91,7 @@ Preferences::Preferences(QWidget *parent) : QMainWindow(parent)
 	QActionGroup *group = new QActionGroup(this);
 	group->addAction(prefsAction3DView);
 	group->addAction(prefsActionEditor);
+	group->addAction(prefsActionUpdate);
 	group->addAction(prefsActionAdvanced);
 	connect(group, SIGNAL(triggered(QAction*)), this, SLOT(actionTriggered(QAction*)));
 
@@ -155,6 +159,9 @@ Preferences::actionTriggered(QAction *action)
 	else if (action == this->prefsActionEditor) {
 		this->stackedWidget->setCurrentWidget(this->pageEditor);
 	}
+	else if (action == this->prefsActionUpdate) {
+		this->stackedWidget->setCurrentWidget(this->pageUpdate);
+	}
 	else if (action == this->prefsActionAdvanced) {
 		this->stackedWidget->setCurrentWidget(this->pageAdvanced);
 	}
@@ -186,6 +193,40 @@ void Preferences::on_fontSize_editTextChanged(const QString &size)
 	emit fontChanged(getValue("editor/fontfamily").toString(), intsize);
 }
 
+void unimplemented_msg()
+{
+  QMessageBox mbox;
+	mbox.setText("Sorry, this feature is not implemented on your Operating System");
+	mbox.exec();
+}
+
+void Preferences::on_updateCheckBox_toggled(bool on)
+{
+	if (AutoUpdater *updater =AutoUpdater::updater()) {
+		updater->setAutomaticallyChecksForUpdates(on);
+	} else {
+		unimplemented_msg();
+	}
+}
+
+void Preferences::on_snapshotCheckBox_toggled(bool on)
+{
+	if (AutoUpdater *updater =AutoUpdater::updater()) {
+		updater->setEnableSnapshots(on);
+	} else {
+		unimplemented_msg();
+	}
+}
+
+void Preferences::on_checkNowButton_clicked()
+{
+	if (AutoUpdater *updater =AutoUpdater::updater()) {
+		updater->checkForUpdates();
+	} else {
+		unimplemented_msg();
+	}
+}
+
 void
 Preferences::on_openCSGWarningBox_toggled(bool state)
 {
@@ -289,6 +330,12 @@ void Preferences::updateGUI()
 		this->fontSize->setEditText(fontsize);
 	}
 
+	if (AutoUpdater *updater = AutoUpdater::updater()) {
+		this->updateCheckBox->setChecked(updater->automaticallyChecksForUpdates());
+		this->snapshotCheckBox->setChecked(updater->enableSnapshots());
+		this->lastCheckedLabel->setText(updater->lastUpdateCheckDate());
+	}
+
 	this->openCSGWarningBox->setChecked(getValue("advanced/opencsg_show_warning").toBool());
 	this->enableOpenCSGBox->setChecked(getValue("advanced/enable_opencsg_opengl1x").toBool());
 	this->cgalCacheSizeEdit->setText(getValue("advanced/cgalCacheSize").toString());
diff --git a/src/Preferences.h b/src/Preferences.h
index 48e07b4..4656793 100644
--- a/src/Preferences.h
+++ b/src/Preferences.h
@@ -30,6 +30,9 @@ public slots:
 	void on_polysetCacheSizeEdit_textChanged(const QString &);
 	void on_opencsgLimitEdit_textChanged(const QString &);
 	void on_forceGoldfeatherBox_toggled(bool);
+	void on_updateCheckBox_toggled(bool);
+	void on_snapshotCheckBox_toggled(bool);
+	void on_checkNowButton_clicked();
 
 signals:
 	void requestRedraw() const;
diff --git a/src/Preferences.ui b/src/Preferences.ui
index 9b4671a..d67db6a 100644
--- a/src/Preferences.ui
+++ b/src/Preferences.ui
@@ -6,10 +6,16 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>531</width>
-    <height>418</height>
+    <width>473</width>
+    <height>320</height>
    </rect>
   </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
   <property name="windowTitle">
    <string>Preferences</string>
   </property>
@@ -173,6 +179,150 @@
         </item>
        </layout>
       </widget>
+      <widget class="QWidget" name="pageUpdate">
+       <layout class="QVBoxLayout" name="verticalLayout_16">
+        <item>
+         <layout class="QHBoxLayout" name="horizontalLayout_9">
+          <item>
+           <layout class="QVBoxLayout" name="verticalLayout_8">
+            <item>
+             <widget class="QCheckBox" name="updateCheckBox">
+              <property name="text">
+               <string>Automatically check for updates</string>
+              </property>
+              <property name="checked">
+               <bool>true</bool>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QCheckBox" name="snapshotCheckBox">
+              <property name="text">
+               <string>Include development snapshots</string>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <spacer name="horizontalSpacer_2">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <layout class="QVBoxLayout" name="verticalLayout_7">
+          <property name="spacing">
+           <number>0</number>
+          </property>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_11">
+            <item>
+             <spacer name="horizontalSpacer_10">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QPushButton" name="checkNowButton">
+              <property name="text">
+               <string>Check Now</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_9">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_10">
+            <item>
+             <spacer name="horizontalSpacer_11">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QLabel" name="lastCheckedLabel">
+              <property name="enabled">
+               <bool>false</bool>
+              </property>
+              <property name="font">
+               <font>
+                <pointsize>11</pointsize>
+               </font>
+              </property>
+              <property name="text">
+               <string>Last checked: </string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_12">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <spacer name="verticalSpacer_7">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>89</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </widget>
       <widget class="QWidget" name="pageAdvanced">
        <layout class="QVBoxLayout" name="verticalLayout_3">
         <item>
@@ -227,9 +377,6 @@
             </widget>
            </item>
           </layout>
-          <zorder>openCSGWarningBox</zorder>
-          <zorder>enableOpenCSGBox</zorder>
-          <zorder>forceGoldfeatherBox</zorder>
          </widget>
         </item>
         <item>
@@ -317,6 +464,7 @@
    </attribute>
    <addaction name="prefsAction3DView"/>
    <addaction name="prefsActionEditor"/>
+   <addaction name="prefsActionUpdate"/>
    <addaction name="prefsActionAdvanced"/>
   </widget>
   <action name="prefsAction3DView">
@@ -355,6 +503,18 @@
     <string>Editor</string>
    </property>
   </action>
+  <action name="prefsActionUpdate">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="icon">
+    <iconset resource="../openscad.qrc">
+     <normaloff>:/icons/prefsUpdate.png</normaloff>:/icons/prefsUpdate.png</iconset>
+   </property>
+   <property name="text">
+    <string>Update</string>
+   </property>
+  </action>
  </widget>
  <resources>
   <include location="../openscad.qrc"/>
diff --git a/src/QGLView.cc b/src/QGLView.cc
new file mode 100644
index 0000000..b23ba8e
--- /dev/null
+++ b/src/QGLView.cc
@@ -0,0 +1,284 @@
+/*
+ *  OpenSCAD (www.openscad.org)
+ *  Copyright (C) 2009-2011 Clifford Wolf <clifford@clifford.at> and
+ *                          Marius Kintel <marius@kintel.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  As a special exception, you have permission to link this program
+ *  with the CGAL library and distribute executables, as long as you
+ *  follow the requirements of the GNU GPL in regard to all of the
+ *  software in the executable aside from CGAL.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "QGLView.h"
+#include "Preferences.h"
+#include "renderer.h"
+
+#include <QApplication>
+#include <QWheelEvent>
+#include <QCheckBox>
+#include <QDialogButtonBox>
+#include <QMouseEvent>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSettings>
+#include <QTimer>
+#include <QTextEdit>
+#include <QVBoxLayout>
+#include <QErrorMessage>
+#include "OpenCSGWarningDialog.h"
+
+#include "mathc99.h"
+#include <stdio.h>
+
+#ifdef ENABLE_OPENCSG
+#  include <opencsg.h>
+#endif
+
+QGLView::QGLView(QWidget *parent) : QGLWidget(parent)
+{
+  init();
+}
+
+QGLView::QGLView(const QGLFormat & format, QWidget *parent) : QGLWidget(format, parent)
+{
+  init();
+}
+
+static bool running_under_wine = false;
+
+void QGLView::init()
+{
+  cam.type = Camera::GIMBAL;
+  cam.object_rot << 35, 0, -25;
+  cam.object_trans << 0, 0, 0;
+  cam.viewer_distance = 500;
+
+  this->mouse_drag_active = false;
+  this->statusLabel = NULL;
+
+  setMouseTracking(true);
+
+// see paintGL() + issue160 + wine FAQ
+#ifdef _WIN32
+#include <windows.h>
+  HMODULE hntdll = GetModuleHandle(L"ntdll.dll");
+  if (hntdll)
+    if ( (void *)GetProcAddress(hntdll, "wine_get_version") )
+      running_under_wine = true;
+#endif
+}
+
+void QGLView::initializeGL()
+{
+  GLenum err = glewInit();
+  if (GLEW_OK != err) {
+    fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
+  }
+  GLView::initializeGL();
+}
+
+std::string QGLView::getRendererInfo() const
+{
+  std::string glewinfo = glew_dump();
+  std::string glextlist = glew_extensions_dump();
+  return glewinfo + std::string("\nUsing QGLWidget\n\n") + glextlist;
+}
+
+#ifdef ENABLE_OPENCSG
+void QGLView::display_opencsg_warning()
+{
+    if (Preferences::inst()->getValue("advanced/opencsg_show_warning").toBool()) {
+      QTimer::singleShot(0, this, SLOT(display_opencsg_warning_dialog()));
+    }
+}
+
+void QGLView::display_opencsg_warning_dialog()
+{
+  OpenCSGWarningDialog *dialog = new OpenCSGWarningDialog(this);
+
+  QString message;
+  if (this->is_opencsg_capable) {
+    message += "Warning: You may experience OpenCSG rendering errors.\n\n";
+  }
+  else {
+    message += "Warning: Missing OpenGL capabilities for OpenCSG - OpenCSG has been disabled.\n\n";
+    dialog->enableOpenCSGBox->hide();
+  }
+  message += "It is highly recommended to use OpenSCAD on a system with "
+    "OpenGL 2.0 or later.\n"
+    "Your renderer information is as follows:\n";
+  QString rendererinfo;
+  rendererinfo.sprintf("GLEW version %s\n"
+                       "%s (%s)\n"
+                       "OpenGL version %s\n",
+                       glewGetString(GLEW_VERSION),
+                       glGetString(GL_RENDERER), glGetString(GL_VENDOR),
+                       glGetString(GL_VERSION));
+  message += rendererinfo;
+
+  dialog->setText(message);
+  dialog->enableOpenCSGBox->setChecked(Preferences::inst()->getValue("advanced/enable_opencsg_opengl1x").toBool());
+  dialog->exec();
+
+  opencsg_support = this->is_opencsg_capable && Preferences::inst()->getValue("advanced/enable_opencsg_opengl1x").toBool();
+}
+#endif
+
+void QGLView::resizeGL(int w, int h)
+{
+  GLView::resizeGL(w,h);
+  GLView::setupGimbalCamPerspective();
+}
+
+void QGLView::paintGL()
+{
+	GLView::gimbalCamPaintGL();
+
+  if (statusLabel) {
+    QString msg;
+    msg.sprintf("Viewport: translate = [ %.2f %.2f %.2f ], rotate = [ %.2f %.2f %.2f ], distance = %.2f",
+      -cam.object_trans.x(), -cam.object_trans.y(), -cam.object_trans.z(),
+      fmodf(360 - cam.object_rot.x() + 90, 360), fmodf(360 - cam.object_rot.y(), 360), fmodf(360 - cam.object_rot.z(), 360), cam.viewer_distance);
+    statusLabel->setText(msg);
+  }
+
+  if (running_under_wine) swapBuffers();
+}
+
+void QGLView::keyPressEvent(QKeyEvent *event)
+{
+  if (event->key() == Qt::Key_Plus) {
+    cam.viewer_distance *= 0.9;
+    updateGL();
+    return;
+  }
+  if (event->key() == Qt::Key_Minus) {
+    cam.viewer_distance /= 0.9;
+    updateGL();
+    return;
+  }
+}
+
+void QGLView::wheelEvent(QWheelEvent *event)
+{
+  cam.viewer_distance *= pow(0.9, event->delta() / 120.0);
+  updateGL();
+}
+
+void QGLView::mousePressEvent(QMouseEvent *event)
+{
+  mouse_drag_active = true;
+  last_mouse = event->globalPos();
+}
+
+void QGLView::normalizeAngle(GLdouble& angle)
+{
+  while(angle < 0)
+    angle += 360;
+  while(angle > 360)
+    angle -= 360;
+}
+
+void QGLView::mouseMoveEvent(QMouseEvent *event)
+{
+  QPoint this_mouse = event->globalPos();
+  double dx = (this_mouse.x()-last_mouse.x()) * 0.7;
+  double dy = (this_mouse.y()-last_mouse.y()) * 0.7;
+  if (mouse_drag_active) {
+    if (event->buttons() & Qt::LeftButton
+#ifdef Q_WS_MAC
+        && !(event->modifiers() & Qt::MetaModifier)
+#endif
+      ) {
+      // Left button rotates in xz, Shift-left rotates in xy
+      // On Mac, Ctrl-Left is handled as right button on other platforms
+      cam.object_rot.x() += dy;
+      if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) != 0)
+        cam.object_rot.y() += dx;
+      else
+        cam.object_rot.z() += dx;
+
+      normalizeAngle(cam.object_rot.x());
+      normalizeAngle(cam.object_rot.y());
+      normalizeAngle(cam.object_rot.z());
+    } else {
+      // Right button pans in the xz plane
+      // Middle button pans in the xy plane
+      // Shift-right and Shift-middle zooms
+      if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) != 0) {
+        cam.viewer_distance += (GLdouble)dy;
+      } else {
+
+      double mx = +(dx) * cam.viewer_distance/1000;
+      double mz = -(dy) * cam.viewer_distance/1000;
+
+      double my = 0;
+#if (QT_VERSION < QT_VERSION_CHECK(4, 7, 0))
+      if (event->buttons() & Qt::MidButton) {
+#else
+      if (event->buttons() & Qt::MiddleButton) {
+#endif
+        my = mz;
+        mz = 0;
+        // actually lock the x-position
+        // (turns out to be easier to use than xy panning)
+        mx = 0;
+      }
+
+      Matrix3d aax, aay, aaz, tm3;
+      aax = Eigen::AngleAxisd(-(cam.object_rot.x()/180) * M_PI, Vector3d::UnitX());
+      aay = Eigen::AngleAxisd(-(cam.object_rot.y()/180) * M_PI, Vector3d::UnitY());
+      aaz = Eigen::AngleAxisd(-(cam.object_rot.z()/180) * M_PI, Vector3d::UnitZ());
+      tm3 = Matrix3d::Identity();
+      tm3 = aaz * (aay * (aax * tm3));
+
+      Matrix4d tm;
+      tm = Matrix4d::Identity();
+      for (int i=0;i<3;i++) for (int j=0;j<3;j++) tm(j,i)=tm3(j,i);
+
+      Matrix4d vec;
+      vec <<
+        0,  0,  0,  mx,
+        0,  0,  0,  my,
+        0,  0,  0,  mz,
+        0,  0,  0,  1
+      ;
+      tm = tm * vec;
+      cam.object_trans.x() += tm(0,3);
+      cam.object_trans.y() += tm(1,3);
+      cam.object_trans.z() += tm(2,3);
+      }
+    }
+    updateGL();
+    emit doAnimateUpdate();
+  }
+  last_mouse = this_mouse;
+}
+
+void QGLView::mouseReleaseEvent(QMouseEvent*)
+{
+  mouse_drag_active = false;
+  releaseMouse();
+}
+
+bool QGLView::save(const char *filename)
+{
+  QImage img = grabFrameBuffer();
+  return img.save(filename, "PNG");
+}
+
diff --git a/src/QGLView.h b/src/QGLView.h
new file mode 100644
index 0000000..f3e3681
--- /dev/null
+++ b/src/QGLView.h
@@ -0,0 +1,76 @@
+#ifndef QGLVIEW_H_
+#define QGLVIEW_H_
+
+#include "system-gl.h"
+#include <QGLWidget>
+#include <QLabel>
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include "GLView.h"
+#include "renderer.h"
+
+class QGLView : public QGLWidget, public GLView
+{
+	Q_OBJECT
+	Q_PROPERTY(bool showFaces READ showFaces WRITE setShowFaces);
+	Q_PROPERTY(bool showEdges READ showEdges WRITE setShowEdges);
+	Q_PROPERTY(bool showAxes READ showAxes WRITE setShowAxes);
+	Q_PROPERTY(bool showCrosshairs READ showCrosshairs WRITE setShowCrosshairs);
+	Q_PROPERTY(bool orthoMode READ orthoMode WRITE setOrthoMode);
+
+public:
+	QGLView(QWidget *parent = NULL);
+	QGLView(const QGLFormat & format, QWidget *parent = NULL);
+#ifdef ENABLE_OPENCSG
+	bool hasOpenCSGSupport() { return this->opencsg_support; }
+#endif
+	// Properties
+	bool showFaces() const { return this->showfaces; }
+	void setShowFaces(bool enabled) { this->showfaces = enabled; }
+	bool showEdges() const { return this->showedges; }
+	void setShowEdges(bool enabled) { this->showedges = enabled; }
+	bool showAxes() const { return this->showaxes; }
+	void setShowAxes(bool enabled) { this->showaxes = enabled; }
+	bool showCrosshairs() const { return this->showcrosshairs; }
+	void setShowCrosshairs(bool enabled) { this->showcrosshairs = enabled; }
+	bool orthoMode() const { return (this->cam.projection == Camera::ORTHOGONAL); }
+	void setOrthoMode(bool enabled) {
+		if (enabled) this->cam.projection = Camera::ORTHOGONAL;
+		else this->cam.projection = Camera::PERSPECTIVE;
+	}
+	std::string getRendererInfo() const;
+	bool save(const char *filename);
+
+public:
+	QLabel *statusLabel;
+
+private:
+	void init();
+
+	bool mouse_drag_active;
+	QPoint last_mouse;
+
+	void keyPressEvent(QKeyEvent *event);
+	void wheelEvent(QWheelEvent *event);
+	void mousePressEvent(QMouseEvent *event);
+	void mouseMoveEvent(QMouseEvent *event);
+	void mouseReleaseEvent(QMouseEvent *event);
+
+	void initializeGL();
+	void resizeGL(int w, int h);
+
+	void paintGL();
+	void normalizeAngle(GLdouble& angle);
+
+#ifdef ENABLE_OPENCSG
+	void display_opencsg_warning();
+private slots:
+	void display_opencsg_warning_dialog();
+#endif
+
+signals:
+	void doAnimateUpdate();
+};
+
+#endif
diff --git a/src/SparkleAutoUpdater.h b/src/SparkleAutoUpdater.h
new file mode 100644
index 0000000..786a190
--- /dev/null
+++ b/src/SparkleAutoUpdater.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2008 Remko Troncon. BSD license
+ * Copyright (C) 2013 Marius Kintel. BSD license
+ */
+#ifndef SPARKLEAUTOUPDATER_H
+#define SPARKLEAUTOUPDATER_H
+
+#include <QString>
+
+#include "AutoUpdater.h"
+
+class SparkleAutoUpdater : public AutoUpdater
+{
+public:
+	SparkleAutoUpdater();
+	~SparkleAutoUpdater();
+	
+	void checkForUpdates();
+	void setAutomaticallyChecksForUpdates(bool on);
+	bool automaticallyChecksForUpdates();
+	void setEnableSnapshots(bool on);
+	bool enableSnapshots();
+	QString lastUpdateCheckDate();
+
+private:
+	void updateFeed();
+
+	class Private;
+	Private *d;
+};
+
+#endif
diff --git a/src/SparkleAutoUpdater.mm b/src/SparkleAutoUpdater.mm
new file mode 100644
index 0000000..c52e2bb
--- /dev/null
+++ b/src/SparkleAutoUpdater.mm
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2008 Remko Troncon. BSD license
+ * Copyright (C) 2013 Marius Kintel. BSD license
+ */
+
+#include "SparkleAutoUpdater.h"
+
+#include <Cocoa/Cocoa.h>
+#include <Sparkle/Sparkle.h>
+
+NSString *const SUEnableSnapshotsKey = @"SUEnableSnapshots";
+
+class SparkleAutoUpdater::Private
+{
+public:
+  SUUpdater* updater;
+};
+
+SparkleAutoUpdater::SparkleAutoUpdater()
+{
+  d = new Private;
+
+  d->updater = [SUUpdater sharedUpdater];
+  [d->updater retain];
+
+  updateFeed();
+}
+
+SparkleAutoUpdater::~SparkleAutoUpdater()
+{
+  [d->updater release];
+  delete d;
+}
+
+void SparkleAutoUpdater::checkForUpdates()
+{
+  [d->updater checkForUpdatesInBackground];
+}
+
+void SparkleAutoUpdater::setAutomaticallyChecksForUpdates(bool on)
+{
+  [d->updater setAutomaticallyChecksForUpdates:on];
+}
+
+bool SparkleAutoUpdater::automaticallyChecksForUpdates()
+{
+  return [d->updater automaticallyChecksForUpdates];
+}
+
+void SparkleAutoUpdater::setEnableSnapshots(bool on)
+{
+  [[NSUserDefaults standardUserDefaults] setBool:on forKey:SUEnableSnapshotsKey];
+  updateFeed();
+}
+
+bool SparkleAutoUpdater::enableSnapshots()
+{
+  return [[NSUserDefaults standardUserDefaults] boolForKey:SUEnableSnapshotsKey];
+}
+
+QString SparkleAutoUpdater::lastUpdateCheckDate()
+{
+  NSDate *date = [d->updater lastUpdateCheckDate];
+  NSString *datestring = date ? [NSString stringWithFormat:@"Last checked: %@", date] : @"";
+  return QString::fromUtf8([datestring UTF8String]);
+}
+
+void SparkleAutoUpdater::updateFeed()
+{
+  NSString *urlstring = [NSString stringWithFormat:@"http://openscad.org/appcast%@.xml", enableSnapshots() ? @"-snapshots" : @""];
+  [d->updater setFeedURL:[NSURL URLWithString:urlstring]];
+}
diff --git a/src/cgaladv.cc b/src/cgaladv.cc
index 1773a90..a4cb5ec 100644
--- a/src/cgaladv.cc
+++ b/src/cgaladv.cc
@@ -58,6 +58,9 @@ AbstractNode *CgaladvModule::evaluate(const Context *ctx, const ModuleInstantiat
 	if (type == SUBDIV)
 		argnames += "type", "level", "convexity";
 
+	if (type == RESIZE)
+		argnames += "newsize", "auto";
+
 	Context c(ctx);
 	c.args(argnames, argexpr, inst->argnames, inst->argvalues);
 
@@ -78,6 +81,28 @@ AbstractNode *CgaladvModule::evaluate(const Context *ctx, const ModuleInstantiat
 		level = c.lookup_variable("level", true);
 	}
 
+	if (type == RESIZE) {
+		Value ns = c.lookup_variable("newsize");
+		node->newsize << 0,0,0;
+		if ( ns.type() == Value::VECTOR ) {
+			Value::VectorType vs = ns.toVector();
+			if ( vs.size() >= 1 ) node->newsize[0] = vs[0].toDouble();
+			if ( vs.size() >= 2 ) node->newsize[1] = vs[1].toDouble();
+			if ( vs.size() >= 3 ) node->newsize[2] = vs[2].toDouble();
+		}
+		Value autosize = c.lookup_variable("auto");
+		node->autosize << false, false, false;
+		if ( autosize.type() == Value::VECTOR ) {
+			Value::VectorType va = autosize.toVector();
+			if ( va.size() >= 1 ) node->autosize[0] = va[0].toBool();
+			if ( va.size() >= 2 ) node->autosize[1] = va[1].toBool();
+			if ( va.size() >= 3 ) node->autosize[2] = va[2].toBool();
+		}
+		else if ( autosize.type() == Value::BOOL ) {
+			node->autosize << true, true, true;
+		}
+	}
+
 	node->convexity = (int)convexity.toDouble();
 	node->path = path;
 	node->subdiv_type = subdiv_type.toString();
@@ -112,6 +137,9 @@ std::string CgaladvNode::name() const
 	case HULL:
 		return "hull";
 		break;
+	case RESIZE:
+		return "resize";
+		break;
 	default:
 		assert(false);
 	}
@@ -135,6 +163,13 @@ std::string CgaladvNode::toString() const
 	case HULL:
 		stream << "()";
 		break;
+	case RESIZE:
+		stream << "(newsize = ["
+		  << this->newsize[0] << "," << this->newsize[1] << "," << this->newsize[2] << "]"
+		  << ", auto = ["
+		  << this->autosize[0] << "," << this->autosize[1] << "," << this->autosize[2] << "]"
+		  << ")";
+		break;
 	default:
 		assert(false);
 	}
@@ -148,4 +183,5 @@ void register_builtin_cgaladv()
 	Builtins::init("glide", new CgaladvModule(GLIDE));
 	Builtins::init("subdiv", new CgaladvModule(SUBDIV));
 	Builtins::init("hull", new CgaladvModule(HULL));
+	Builtins::init("resize", new CgaladvModule(RESIZE));
 }
diff --git a/src/cgaladvnode.h b/src/cgaladvnode.h
index 8e769bf..d3aa525 100644
--- a/src/cgaladvnode.h
+++ b/src/cgaladvnode.h
@@ -4,12 +4,14 @@
 #include "node.h"
 #include "visitor.h"
 #include "value.h"
+#include "linalg.h"
 
 enum cgaladv_type_e {
 	MINKOWSKI,
 	GLIDE,
 	SUBDIV,
-	HULL
+	HULL,
+	RESIZE
 };
 
 class CgaladvNode : public AbstractNode
@@ -29,6 +31,8 @@ public:
 	Value path;
 	std::string subdiv_type;
 	int convexity, level;
+	Vector3d newsize;
+	Eigen::Matrix<bool,3,1> autosize;
 	cgaladv_type_e type;
 };
 
diff --git a/src/cgalutils.cc b/src/cgalutils.cc
index 51838df..8b4c476 100644
--- a/src/cgalutils.cc
+++ b/src/cgalutils.cc
@@ -147,7 +147,7 @@ CGAL_Polyhedron *createPolyhedronFromPolySet(const PolySet &ps)
 
 CGAL_Iso_cuboid_3 bounding_box( const CGAL_Nef_polyhedron3 &N )
 {
-	CGAL_Iso_cuboid_3 result(-1,-1,-1,1,1,1);
+	CGAL_Iso_cuboid_3 result(0,0,0,0,0,0);
 	CGAL_Nef_polyhedron3::Vertex_const_iterator vi;
 	std::vector<CGAL_Nef_polyhedron3::Point_3> points;
 	// can be optimized by rewriting bounding_box to accept vertices
@@ -160,7 +160,7 @@ CGAL_Iso_cuboid_3 bounding_box( const CGAL_Nef_polyhedron3 &N )
 
 CGAL_Iso_rectangle_2e bounding_box( const CGAL_Nef_polyhedron2 &N )
 {
-	CGAL_Iso_rectangle_2e result(-1,-1,1,1);
+	CGAL_Iso_rectangle_2e result(0,0,0,0);
 	CGAL_Nef_polyhedron2::Explorer explorer = N.explorer();
 	CGAL_Nef_polyhedron2::Explorer::Vertex_const_iterator vi;
 	std::vector<CGAL_Point_2e> points;
@@ -173,5 +173,56 @@ CGAL_Iso_rectangle_2e bounding_box( const CGAL_Nef_polyhedron2 &N )
 	return result;
 }
 
+void ZRemover::visit( CGAL_Nef_polyhedron3::Halffacet_const_handle hfacet )
+{
+	log << " <!-- ZRemover Halffacet visit. Mark: " << hfacet->mark() << " -->\n";
+	if ( hfacet->plane().orthogonal_direction() != this->up ) {
+		log << "  <!-- ZRemover down-facing half-facet. skipping -->\n";
+		log << " <!-- ZRemover Halffacet visit end-->\n";
+		return;
+	}
+
+	// possible optimization - throw out facets that are vertically oriented
+
+	CGAL_Nef_polyhedron3::Halffacet_cycle_const_iterator fci;
+	int contour_counter = 0;
+	CGAL_forall_facet_cycles_of( fci, hfacet ) {
+		if ( fci.is_shalfedge() ) {
+			log << " <!-- ZRemover Halffacet cycle begin -->\n";
+			CGAL_Nef_polyhedron3::SHalfedge_around_facet_const_circulator c1(fci), cend(c1);
+			std::vector<CGAL_Nef_polyhedron2::Explorer::Point> contour;
+			CGAL_For_all( c1, cend ) {
+				CGAL_Nef_polyhedron3::Point_3 point3d = c1->source()->target()->point();
+				CGAL_Nef_polyhedron2::Explorer::Point point2d( point3d.x(), point3d.y() );
+				contour.push_back( point2d );
+			}
+			if (contour.size()==0) continue;
+
+			log << " <!-- is_simple_2:" << CGAL::is_simple_2( contour.begin(), contour.end() ) << " --> \n";
+
+			tmpnef2d.reset( new CGAL_Nef_polyhedron2( contour.begin(), contour.end(), boundary ) );
+
+			if ( contour_counter == 0 ) {
+				log << " <!-- contour is a body. make union(). " << contour.size() << " points. -->\n" ;
+				*(output_nefpoly2d) += *(tmpnef2d);
+			} else {
+				log << " <!-- contour is a hole. make intersection(). " << contour.size() << " points. -->\n";
+				*(output_nefpoly2d) *= *(tmpnef2d);
+			}
+
+			/*log << "\n<!-- ======== output tmp nef: ==== -->\n"
+				<< OpenSCAD::dump_svg( *tmpnef2d ) << "\n"
+				<< "\n<!-- ======== output accumulator: ==== -->\n"
+				<< OpenSCAD::dump_svg( *output_nefpoly2d ) << "\n";*/
+
+			contour_counter++;
+		} else {
+			log << " <!-- ZRemover trivial facet cycle skipped -->\n";
+		}
+		log << " <!-- ZRemover Halffacet cycle end -->\n";
+	}
+	log << " <!-- ZRemover Halffacet visit end -->\n";
+}
+
 #endif /* ENABLE_CGAL */
 
diff --git a/src/cgalutils.h b/src/cgalutils.h
index 9093c3f..6ea7711 100644
--- a/src/cgalutils.h
+++ b/src/cgalutils.h
@@ -2,10 +2,63 @@
 #define CGALUTILS_H_
 
 #include <cgalfwd.h>
-
 class PolySet *createPolySetFromPolyhedron(const CGAL_Polyhedron &p);
 CGAL_Polyhedron *createPolyhedronFromPolySet(const class PolySet &ps);
 CGAL_Iso_cuboid_3 bounding_box( const CGAL_Nef_polyhedron3 &N );
 CGAL_Iso_rectangle_2e bounding_box( const CGAL_Nef_polyhedron2 &N );
 
+#include "svg.h"
+#include "printutils.h"
+
+/*
+
+ZRemover
+
+This class converts one or more Nef3 polyhedra into a Nef2 polyhedron by
+stripping off the 'z' coordinates from the vertices. The resulting Nef2
+poly is accumulated in the 'output_nefpoly2d' member variable.
+
+The 'z' coordinates will either be all 0s, for an xy-plane intersected Nef3,
+or, they will be a mixture of -eps and +eps, for a thin-box intersected Nef3.
+
+Notes on CGAL's Nef Polyhedron2:
+
+1. The 'mark' on a 2d Nef face is important when doing unions/intersections.
+ If the 'mark' of a face is wrong the resulting nef2 poly will be unexpected.
+2. The 'mark' can be dependent on the points fed to the Nef2 constructor.
+ This is why we iterate through the 3d faces using the halfedge cycle
+ source()->target() instead of the ordinary source()->source(). The
+ the latter can generate sequences of points that will fail the
+ the CGAL::is_simple_2() test, resulting in improperly marked nef2 polys.
+3. 3d facets have 'two sides'. we throw out the 'down' side to prevent dups.
+
+The class uses the 'visitor' pattern from the CGAL manual. See also
+http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3/Chapter_main.html
+http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3_ref/Class_Nef_polyhedron3.html
+OGL_helper.h
+*/
+
+class ZRemover {
+public:
+	logstream log;
+	CGAL_Nef_polyhedron2::Boundary boundary;
+	boost::shared_ptr<CGAL_Nef_polyhedron2> tmpnef2d;
+	boost::shared_ptr<CGAL_Nef_polyhedron2> output_nefpoly2d;
+	CGAL::Direction_3<CGAL_Kernel3> up;
+	ZRemover()
+	{
+		output_nefpoly2d.reset( new CGAL_Nef_polyhedron2() );
+		boundary = CGAL_Nef_polyhedron2::INCLUDED;
+		up = CGAL::Direction_3<CGAL_Kernel3>(0,0,1);
+		log = logstream(5);
+	}
+	void visit( CGAL_Nef_polyhedron3::Vertex_const_handle ) {}
+	void visit( CGAL_Nef_polyhedron3::Halfedge_const_handle ) {}
+	void visit( CGAL_Nef_polyhedron3::SHalfedge_const_handle ) {}
+	void visit( CGAL_Nef_polyhedron3::SHalfloop_const_handle ) {}
+	void visit( CGAL_Nef_polyhedron3::SFace_const_handle ) {}
+	void visit( CGAL_Nef_polyhedron3::Halffacet_const_handle hfacet );
+};
+
+
 #endif
diff --git a/src/context.cc b/src/context.cc
index a2a8d13..97ea5b9 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -51,9 +51,8 @@ Context::Context(const Context *parent, const Module *library)
 		this->functions_p = &library->functions;
 		this->modules_p = &library->modules;
 		this->usedlibs_p = &library->usedlibs;
-		for (size_t j = 0; j < library->assignments_var.size(); j++) {
-			this->set_variable(library->assignments_var[j], 
-												 library->assignments_expr[j]->evaluate(this));
+		BOOST_FOREACH(const std::string &var, library->assignments_var) {
+			this->set_variable(var, library->assignments.at(var)->evaluate(this));
 		}
 	}
 	else {
diff --git a/src/context.h b/src/context.h
index de5f1ca..eb9a175 100644
--- a/src/context.h
+++ b/src/context.h
@@ -6,8 +6,6 @@
 #include <boost/unordered_map.hpp>
 #include "value.h"
 
-using boost::unordered_map;
-
 class Context
 {
 public:
@@ -33,18 +31,18 @@ public:
 
 public:
 	const Context *parent;
-	const unordered_map<std::string, class AbstractFunction*> *functions_p;
-	const unordered_map<std::string, class AbstractModule*> *modules_p;
-	typedef unordered_map<std::string, class Module*> ModuleContainer;
+	const boost::unordered_map<std::string, class AbstractFunction*> *functions_p;
+	const boost::unordered_map<std::string, class AbstractModule*> *modules_p;
+	typedef boost::unordered_map<std::string, class Module*> ModuleContainer;
 	const ModuleContainer *usedlibs_p;
 	const ModuleInstantiation *inst_p;
 
 	static std::vector<const Context*> ctx_stack;
 
-	mutable unordered_map<std::string, int> recursioncount;
+	mutable boost::unordered_map<std::string, int> recursioncount;
 
 private:
-	typedef unordered_map<std::string, Value> ValueMap;
+	typedef boost::unordered_map<std::string, Value> ValueMap;
 	ValueMap constants;
 	ValueMap variables;
 	ValueMap config_variables;
diff --git a/src/dxfdata.cc b/src/dxfdata.cc
index 2fd40ab..f34af51 100644
--- a/src/dxfdata.cc
+++ b/src/dxfdata.cc
@@ -389,10 +389,10 @@ DxfData::DxfData(double fn, double fs, double fa,
 	BOOST_FOREACH(const EntityList::value_type &i, unsupported_entities_list) {
 		if (layername.empty()) {
 			PRINTB("WARNING: Unsupported DXF Entity '%s' (%x) in %s.",
-						 i.first % i.second % QuotedString(QDir::current().relativeFilePath(QString::fromStdString(filename)).toStdString()));
+						 i.first % i.second % QuotedString(QDir::current().relativeFilePath(QString::fromLocal8Bit(filename.c_str())).toLocal8Bit().constData()));
 		} else {
 			PRINTB("WARNING: Unsupported DXF Entity '%s' (%x) in layer '%s' of %s.",
-						 i.first % i.second % layername % QuotedString(QDir::current().relativeFilePath(QString::fromStdString(filename)).toStdString()));
+						 i.first % i.second % layername % QuotedString(QDir::current().relativeFilePath(QString::fromLocal8Bit(filename.c_str())).toLocal8Bit().constData()));
 		}
 	}
 
diff --git a/src/export.cc b/src/export.cc
index 80670ea..ec6e576 100644
--- a/src/export.cc
+++ b/src/export.cc
@@ -42,7 +42,7 @@ void export_stl(CGAL_Nef_polyhedron *root_N, std::ostream &output)
 	CGAL::Failure_behaviour old_behaviour = CGAL::set_error_behaviour(CGAL::THROW_EXCEPTION);
 	try {
 	CGAL_Polyhedron P;
-  root_N->p3->convert_to_Polyhedron(P);
+	root_N->p3->convert_to_Polyhedron(P);
 
 	typedef CGAL_Polyhedron::Vertex                                 Vertex;
 	typedef CGAL_Polyhedron::Vertex_const_iterator                  VCI;
@@ -195,7 +195,7 @@ void export_dxf(CGAL_Nef_polyhedron *root_N, std::ostream &output)
 	setlocale(LC_NUMERIC, "");      // Set default locale
 }
 
-#endif
+#endif // ENABLE_CGAL
 
 #ifdef DEBUG
 #include <boost/foreach.hpp>
diff --git a/src/export.h b/src/export.h
index 3897be0..a565561 100644
--- a/src/export.h
+++ b/src/export.h
@@ -2,12 +2,16 @@
 #define EXPORT_H_
 
 #include <iostream>
+#include "Tree.h"
+#include "Camera.h"
 
 #ifdef ENABLE_CGAL
 
 void export_stl(class CGAL_Nef_polyhedron *root_N, std::ostream &output);
 void export_off(CGAL_Nef_polyhedron *root_N, std::ostream &output);
 void export_dxf(CGAL_Nef_polyhedron *root_N, std::ostream &output);
+void export_png_with_cgal(CGAL_Nef_polyhedron *root_N, Camera &c, std::ostream &output);
+void export_png_with_opencsg(Tree &tree, Camera &c, std::ostream &output);
 
 #endif
 
diff --git a/src/export_png.cc b/src/export_png.cc
new file mode 100644
index 0000000..c6c191c
--- /dev/null
+++ b/src/export_png.cc
@@ -0,0 +1,100 @@
+#include "export.h"
+#include "printutils.h"
+#include "OffscreenView.h"
+#include "CsgInfo.h"
+#include <stdio.h>
+#include "polyset.h"
+#include "rendersettings.h"
+
+#ifdef ENABLE_CGAL
+#include "CGALRenderer.h"
+#include "CGAL_renderer.h"
+#include "cgal.h"
+
+void export_png_with_cgal(CGAL_Nef_polyhedron *root_N, Camera &cam, std::ostream &output)
+{
+	OffscreenView *glview;
+	try {
+		glview = new OffscreenView( cam.pixel_width, cam.pixel_height );
+	} catch (int error) {
+		fprintf(stderr,"Can't create OpenGL OffscreenView. Code: %i.\n", error);
+		return;
+	}
+	CGALRenderer cgalRenderer(*root_N);
+
+	BoundingBox bbox;
+	if (cgalRenderer.polyhedron) {
+		CGAL::Bbox_3 cgalbbox = cgalRenderer.polyhedron->bbox();
+		bbox = BoundingBox(
+		  Vector3d(cgalbbox.xmin(), cgalbbox.ymin(), cgalbbox.zmin()),
+		  Vector3d(cgalbbox.xmax(), cgalbbox.ymax(), cgalbbox.zmax())  );
+	}
+	else if (cgalRenderer.polyset) {
+		bbox = cgalRenderer.polyset->getBoundingBox();
+	}
+
+	if (cam.type == Camera::NONE) {
+		cam.type = Camera::VECTOR;
+		cam.center = getBoundingCenter(bbox);
+		double radius = getBoundingRadius(bbox);
+		Vector3d cameradir(1, 1, -0.5);
+		cam.eye = cam.center - radius*2*cameradir;
+	}
+
+	//std::cerr << center << "\n";
+	//std::cerr << radius << "\n";
+
+	glview->setCamera( cam );
+	glview->setRenderer(&cgalRenderer);
+	glview->paintGL();
+	glview->save(output);
+}
+
+#ifdef ENABLE_OPENCSG
+#include "OpenCSGRenderer.h"
+#include <opencsg.h>
+#endif
+
+void export_png_with_opencsg(Tree &tree, Camera &cam, std::ostream &output)
+{
+#ifdef ENABLE_OPENCSG
+  CsgInfo csgInfo = CsgInfo();
+  if ( !csgInfo.compile_chains( tree ) ) {
+		fprintf(stderr,"Couldn't initialize OpenCSG chains\n");
+		return;
+	}
+
+	try {
+		csgInfo.glview = new OffscreenView( cam.pixel_width, cam.pixel_height );
+	} catch (int error) {
+		fprintf(stderr,"Can't create OpenGL OffscreenView. Code: %i.\n", error);
+		return;
+	}
+
+	OpenCSGRenderer opencsgRenderer(csgInfo.root_chain, csgInfo.highlights_chain, csgInfo.background_chain, csgInfo.glview->shaderinfo);
+
+	if (cam.type == Camera::NONE) {
+		cam.type = Camera::VECTOR;
+		double radius = 1.0;
+		if (csgInfo.root_chain) {
+			BoundingBox bbox = csgInfo.root_chain->getBoundingBox();
+			cam.center = (bbox.min() + bbox.max()) / 2;
+			radius = (bbox.max() - bbox.min()).norm() / 2;
+		}
+		Vector3d cameradir(1, 1, -0.5);
+		cam.eye = cam.center - radius*1.8*cameradir;
+	}
+
+	csgInfo.glview->setCamera( cam );
+	csgInfo.glview->setRenderer(&opencsgRenderer);
+	OpenCSG::setContext(0);
+	OpenCSG::setOption(OpenCSG::OffscreenSetting, OpenCSG::FrameBufferObject);
+	csgInfo.glview->paintGL();
+	csgInfo.glview->save(output);
+#else
+	fprintf(stderr,"This openscad was built without OpenCSG support\n");
+#endif
+}
+
+
+#endif // ENABLE_CGAL
diff --git a/src/fbo.cc b/src/fbo.cc
new file mode 100644
index 0000000..186cb95
--- /dev/null
+++ b/src/fbo.cc
@@ -0,0 +1,237 @@
+#include "fbo.h"
+#include "system-gl.h"
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+
+fbo_t *fbo_new()
+{
+  fbo_t *fbo = new fbo_t;
+  fbo->fbo_id = 0;
+  fbo->old_fbo_id = 0;
+  fbo->renderbuf_id = 0;
+  fbo->depthbuf_id = 0;
+
+  return fbo;
+}
+
+bool use_ext()
+{
+  // do we need to use the EXT or ARB version?
+  if (!glewIsSupported("GL_ARB_framebuffer_object") &&
+        glewIsSupported("GL_EXT_framebuffer_object")) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool check_fbo_status()
+{
+	/* This code is based on user V-man code from
+	http://www.opengl.org/wiki/GL_EXT_framebuffer_multisample
+	See also: http://www.songho.ca/opengl/gl_fbo.html */
+	GLenum status;
+	bool result = false;
+	if (use_ext())
+		status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+	else
+		status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+	if (report_glerror("checking framebuffer status")) return false;
+
+	if (status == GL_FRAMEBUFFER_COMPLETE)
+		result = true;
+	else if (status == GL_FRAMEBUFFER_UNSUPPORTED)
+		cerr << "GL_FRAMEBUFFER_UNSUPPORTED\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n";
+	else if (status == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT)
+		cerr << "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT\n";
+	else
+		cerr << "Unknown Code: glCheckFramebufferStatusEXT returned:" << status <<"\n";
+	return result;
+}
+
+bool fbo_ext_init(fbo_t *fbo, size_t width, size_t height)
+{
+  // Generate and bind FBO
+  glGenFramebuffersEXT(1, &fbo->fbo_id);
+  if (report_glerror("glGenFramebuffersEXT")) return false;
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo->fbo_id);
+  if (report_glerror("glBindFramebufferEXT")) return false;
+
+  // Generate depth and render buffers
+  glGenRenderbuffersEXT(1, &fbo->depthbuf_id);
+  glGenRenderbuffersEXT(1, &fbo->renderbuf_id);
+
+  // Create buffers with correct size
+  if (!fbo_resize(fbo, width, height)) return false;
+
+  // Attach render and depth buffers
+  glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 
+                               GL_RENDERBUFFER_EXT, fbo->renderbuf_id);
+  if (report_glerror("specifying color render buffer EXT")) return false;
+
+
+  if (!check_fbo_status()) {
+    cerr << "Problem with OpenGL EXT framebuffer after specifying color render buffer.\n";
+    return false;
+  }
+
+	if (glewIsSupported("GL_EXT_packed_depth_stencil")) {
+		glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
+																 GL_RENDERBUFFER_EXT, fbo->depthbuf_id);
+		if (report_glerror("specifying depth render buffer EXT")) return false;
+
+		glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
+																 GL_RENDERBUFFER_EXT, fbo->depthbuf_id);
+		if (report_glerror("specifying stencil render buffer EXT")) return false;
+		
+		if (!check_fbo_status()) {
+			cerr << "Problem with OpenGL EXT framebuffer after specifying depth render buffer.\n";
+			return false;
+		}
+	}
+	else {
+		cerr << "Warning: Cannot create stencil buffer (GL_EXT_packed_depth_stencil not supported)\n";
+		glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, 
+																 GL_RENDERBUFFER_EXT, fbo->depthbuf_id);
+		if (report_glerror("specifying depth render buffer EXT")) return false;
+		
+		if (!check_fbo_status()) {
+			cerr << "Problem with OpenGL EXT framebuffer after specifying depth stencil render buffer.\n";
+			return false;
+		}
+	}
+
+  return true;
+}
+
+bool fbo_arb_init(fbo_t *fbo, size_t width, size_t height)
+{
+  // Generate and bind FBO
+  glGenFramebuffers(1, &fbo->fbo_id);
+  if (report_glerror("glGenFramebuffers")) return false;
+  glBindFramebuffer(GL_FRAMEBUFFER, fbo->fbo_id);
+  if (report_glerror("glBindFramebuffer")) return false;
+
+  // Generate depth and render buffers
+  glGenRenderbuffers(1, &fbo->depthbuf_id);
+  glGenRenderbuffers(1, &fbo->renderbuf_id);
+
+  // Create buffers with correct size
+  if (!fbo_resize(fbo, width, height)) return false;
+
+  // Attach render and depth buffers
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 
+                               GL_RENDERBUFFER, fbo->renderbuf_id);
+  if (report_glerror("specifying color render buffer")) return false;
+
+  if (!check_fbo_status()) {
+    cerr << "Problem with OpenGL framebuffer after specifying color render buffer.\n";
+    return false;
+  }
+
+  //glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 
+  // to prevent Mesa's software renderer from crashing, do this in two stages. 
+  // ie. instead of using GL_DEPTH_STENCIL_ATTACHMENT, do DEPTH then STENCIL. 
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                               GL_RENDERBUFFER, fbo->depthbuf_id);
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, 
+                               GL_RENDERBUFFER, fbo->depthbuf_id);
+  if (report_glerror("specifying depth stencil render buffer")) return false;
+
+  if (!check_fbo_status()) {
+    cerr << "Problem with OpenGL framebuffer after specifying depth render buffer.\n";
+    return false;
+  }
+
+  return true;
+}
+
+
+bool fbo_init(fbo_t *fbo, size_t width, size_t height)
+{
+  /*
+  Some OpenGL drivers include the framebuffer functions but not with
+  core or ARB names, only with the EXT name. This has been worked-around
+  by deciding at runtime, using GLEW, which version needs to be used. See also:
+  
+  http://www.opengl.org/wiki/Framebuffer_Object
+  http://stackoverflow.com/questions/6912988/glgenframebuffers-or-glgenframebuffersex
+  http://www.devmaster.net/forums/showthread.php?t=10967
+  */
+
+  bool result = false;
+  if (glewIsSupported("GL_ARB_framebuffer_object"))
+    result = fbo_arb_init(fbo, width, height);
+  else if (use_ext())
+    result = fbo_ext_init(fbo, width, height);
+  else
+    cerr << "Framebuffer Object extension not found by GLEW\n";
+  return result;
+}
+
+bool fbo_resize(fbo_t *fbo, size_t width, size_t height)
+{
+  if (use_ext()) {
+    glBindRenderbufferEXT(GL_RENDERBUFFER, fbo->depthbuf_id);
+		if (glewIsSupported("GL_EXT_packed_depth_stencil")) {
+			glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
+			if (report_glerror("creating EXT depth stencil render buffer")) return false;
+		}
+		else {
+			glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
+			if (report_glerror("creating EXT depth render buffer")) return false;
+		}
+
+    glBindRenderbufferEXT(GL_RENDERBUFFER, fbo->renderbuf_id);
+    glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_RGBA8, width, height);
+    if (report_glerror("creating EXT color render buffer")) return false;
+  } else {
+    glBindRenderbuffer(GL_RENDERBUFFER, fbo->renderbuf_id);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);
+    if (report_glerror("creating color render buffer")) return false;
+
+    glBindRenderbuffer(GL_RENDERBUFFER, fbo->depthbuf_id);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
+    if (report_glerror("creating depth stencil render buffer")) return false;
+
+  }
+
+  return true;
+}
+
+void fbo_delete(fbo_t *fbo)
+{
+  delete fbo;
+}
+
+GLuint fbo_bind(fbo_t *fbo)
+{
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *)&fbo->old_fbo_id);
+  if (use_ext())
+    glBindFramebufferEXT(GL_FRAMEBUFFER, fbo->fbo_id);
+  else
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo->fbo_id);
+  return fbo->old_fbo_id;
+}
+
+void fbo_unbind(fbo_t *fbo)
+{
+  if (use_ext())
+    glBindFramebufferEXT(GL_FRAMEBUFFER, fbo->old_fbo_id);
+  else
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo->old_fbo_id);
+}
diff --git a/src/fbo.h b/src/fbo.h
new file mode 100644
index 0000000..943862f
--- /dev/null
+++ b/src/fbo.h
@@ -0,0 +1,25 @@
+#ifndef FBO_H_
+#define FBO_H_
+
+#include "system-gl.h"
+#include <stddef.h> // size_t
+
+struct fbo_t
+{
+  GLuint fbo_id;
+  GLuint old_fbo_id;
+
+  GLuint renderbuf_id;
+  GLuint depthbuf_id;
+};
+
+fbo_t *fbo_new();
+bool fbo_init(fbo_t *fbo, size_t width, size_t height);
+bool fbo_resize(fbo_t *fbo, size_t width, size_t height);
+void fbo_delete(fbo_t *fbo);
+GLuint fbo_bind(fbo_t *fbo);
+void fbo_unbind(fbo_t *fbo);
+
+bool REPORTGLERROR(const char * task);
+
+#endif
diff --git a/src/glview.cc b/src/glview.cc
deleted file mode 100644
index 859bf82..0000000
--- a/src/glview.cc
+++ /dev/null
@@ -1,660 +0,0 @@
-/*
- *  OpenSCAD (www.openscad.org)
- *  Copyright (C) 2009-2011 Clifford Wolf <clifford@clifford.at> and
- *                          Marius Kintel <marius@kintel.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  As a special exception, you have permission to link this program
- *  with the CGAL library and distribute executables, as long as you
- *  follow the requirements of the GNU GPL in regard to all of the
- *  software in the executable aside from CGAL.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
-#include "GLView.h"
-#include "Preferences.h"
-#include "renderer.h"
-#include "rendersettings.h"
-#include "linalg.h"
-
-#include <QApplication>
-#include <QWheelEvent>
-#include <QCheckBox>
-#include <QDialogButtonBox>
-#include <QMouseEvent>
-#include <QMessageBox>
-#include <QPushButton>
-#include <QSettings>
-#include <QTimer>
-#include <QTextEdit>
-#include <QVBoxLayout>
-#include <QErrorMessage>
-#include "OpenCSGWarningDialog.h"
-
-#include "mathc99.h"
-#include <stdio.h>
-
-#ifdef ENABLE_OPENCSG
-#  include <opencsg.h>
-#endif
-
-#ifdef _WIN32
-#include <GL/wglew.h>
-#elif !defined(__APPLE__)
-#include <GL/glxew.h>
-#endif
-
-#define FAR_FAR_AWAY 100000.0
-
-GLView::GLView(QWidget *parent) : QGLWidget(parent), renderer(NULL)
-{
-	init();
-}
-
-GLView::GLView(const QGLFormat & format, QWidget *parent) : QGLWidget(format, parent)
-{
-	init();
-}
-
-static bool running_under_wine = false;
-
-void GLView::init()
-{
-	this->viewer_distance = 500;
-	this->object_rot_x = 35;
-	this->object_rot_y = 0;
-	this->object_rot_z = -25;
-	this->object_trans_x = 0;
-	this->object_trans_y = 0;
-	this->object_trans_z = 0;
-
-	this->mouse_drag_active = false;
-
-	this->showedges = false;
-	this->showfaces = true;
-	this->orthomode = false;
-	this->showaxes = false;
-	this->showcrosshairs = false;
-
-	for (int i = 0; i < 10; i++)
-		this->shaderinfo[i] = 0;
-
-	this->statusLabel = NULL;
-
-	setMouseTracking(true);
-#ifdef ENABLE_OPENCSG
-	this->is_opencsg_capable = false;
-	this->has_shaders = false;
-	this->opencsg_support = true;
-	static int sId = 0;
-	this->opencsg_id = sId++;
-#endif
-
-// see paintGL() + issue160 + wine FAQ
-#ifdef _WIN32
-#include <windows.h>
-	HMODULE hntdll = GetModuleHandle(L"ntdll.dll");
-	if (hntdll)
-		if ( (void *)GetProcAddress(hntdll, "wine_get_version") )
-			running_under_wine = true;
-#endif
-}
-
-void GLView::setRenderer(Renderer *r)
-{
-	this->renderer = r;
-	if (r) updateGL(); // Let the last image stay, e.g. to avoid animation flickering
-}
-
-void GLView::initializeGL()
-{
-	glEnable(GL_DEPTH_TEST);
-	glDepthRange(-FAR_FAR_AWAY, +FAR_FAR_AWAY);
-
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-	GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
-	GLfloat light_position0[] = {-1.0, -1.0, +1.0, 0.0};
-	GLfloat light_position1[] = {+1.0, +1.0, -1.0, 0.0};
-
-	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
-	glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
-	glEnable(GL_LIGHT0);
-	glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
-	glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
-	glEnable(GL_LIGHT1);
-	glEnable(GL_LIGHTING);
-	glEnable(GL_NORMALIZE);
-
-	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
-	glEnable(GL_COLOR_MATERIAL);
-
-#ifdef ENABLE_OPENCSG
-	GLenum err = glewInit();
-	if (GLEW_OK != err) {
-		fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
-	}
-
-	GLint rbits, gbits, bbits, abits, dbits, sbits;
-	glGetIntegerv(GL_RED_BITS, &rbits);
-	glGetIntegerv(GL_GREEN_BITS, &gbits);
-	glGetIntegerv(GL_BLUE_BITS, &bbits);
-	glGetIntegerv(GL_ALPHA_BITS, &abits);
-	glGetIntegerv(GL_DEPTH_BITS, &dbits);
-	glGetIntegerv(GL_STENCIL_BITS, &sbits);
-
-
-	this->rendererInfo.sprintf("GLEW version %s\n"
-														 "OpenGL version %s\n"
-														 "%s (%s)\n\n"
-														 "RGBA(%d%d%d%d), depth(%d), stencil(%d)\n"
-														 "Extensions:\n"
-														 "%s\n",
-														 glewGetString(GLEW_VERSION),
-														 glGetString(GL_VERSION),
-														 glGetString(GL_RENDERER),
-														 glGetString(GL_VENDOR),
-														 rbits, gbits, bbits, abits, dbits, sbits,
-														 glGetString(GL_EXTENSIONS));
-// FIXME: glGetString(GL_EXTENSIONS) is deprecated in OpenGL 3.0.
-// Use: glGetIntegerv(GL_NUM_EXTENSIONS, &NumberOfExtensions) and 
-// glGetStringi(GL_EXTENSIONS, i)
-
-	const char *openscad_disable_gl20_env = getenv("OPENSCAD_DISABLE_GL20");
-	if (openscad_disable_gl20_env && !strcmp(openscad_disable_gl20_env, "0")) {
-		openscad_disable_gl20_env = NULL;
-	}
-
-	// All OpenGL 2 contexts are OpenCSG capable
-	if (GLEW_VERSION_2_0) {
-		if (!openscad_disable_gl20_env) {
-			this->is_opencsg_capable = true;
-			this->has_shaders = true;
-		}
-	}
-	// If OpenGL < 2, check for extensions
-	else {
-		if (GLEW_ARB_framebuffer_object) this->is_opencsg_capable = true;
-		else if (GLEW_EXT_framebuffer_object && GLEW_EXT_packed_depth_stencil) {
-			this->is_opencsg_capable = true;
-		}
-#ifdef WIN32
-		else if (WGLEW_ARB_pbuffer && WGLEW_ARB_pixel_format) this->is_opencsg_capable = true;
-#elif !defined(__APPLE__)
-		else if (GLXEW_SGIX_pbuffer && GLXEW_SGIX_fbconfig) this->is_opencsg_capable = true;
-#endif
-	}
-
-	if (!GLEW_VERSION_2_0 || !this->is_opencsg_capable) {
-		if (Preferences::inst()->getValue("advanced/opencsg_show_warning").toBool()) {
-			QTimer::singleShot(0, this, SLOT(display_opencsg_warning()));
-		}
-	}
-	if (opencsg_support && this->has_shaders) {
-  /*
-		Uniforms:
-		  1 color1 - face color
-			2 color2 - edge color
-			7 xscale
-			8 yscale
-
-		Attributes:
-		  3 trig
-			4 pos_b
-			5 pos_c
-			6 mask
-
-		Other:
-		  9 width
-			10 height
-
-		Outputs:
-		  tp
-			tr
-			shading
-	 */
-		const char *vs_source =
-			"uniform float xscale, yscale;\n"
-			"attribute vec3 pos_b, pos_c;\n"
-			"attribute vec3 trig, mask;\n"
-			"varying vec3 tp, tr;\n"
-			"varying float shading;\n"
-			"void main() {\n"
-			"  vec4 p0 = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
-			"  vec4 p1 = gl_ModelViewProjectionMatrix * vec4(pos_b, 1.0);\n"
-			"  vec4 p2 = gl_ModelViewProjectionMatrix * vec4(pos_c, 1.0);\n"
-			"  float a = distance(vec2(xscale*p1.x/p1.w, yscale*p1.y/p1.w), vec2(xscale*p2.x/p2.w, yscale*p2.y/p2.w));\n"
-			"  float b = distance(vec2(xscale*p0.x/p0.w, yscale*p0.y/p0.w), vec2(xscale*p1.x/p1.w, yscale*p1.y/p1.w));\n"
-			"  float c = distance(vec2(xscale*p0.x/p0.w, yscale*p0.y/p0.w), vec2(xscale*p2.x/p2.w, yscale*p2.y/p2.w));\n"
-			"  float s = (a + b + c) / 2.0;\n"
-			"  float A = sqrt(s*(s-a)*(s-b)*(s-c));\n"
-			"  float ha = 2.0*A/a;\n"
-			"  gl_Position = p0;\n"
-			"  tp = mask * ha;\n"
-			"  tr = trig;\n"
-			"  vec3 normal, lightDir;\n"
-			"  normal = normalize(gl_NormalMatrix * gl_Normal);\n"
-			"  lightDir = normalize(vec3(gl_LightSource[0].position));\n"
-			"  shading = abs(dot(normal, lightDir));\n"
-			"}\n";
-
-		/*
-			Inputs:
-			  tp && tr - if any components of tp < tr, use color2 (edge color)
-				shading  - multiplied by color1. color2 is is without lighting
-		 */
-		const char *fs_source =
-			"uniform vec4 color1, color2;\n"
-			"varying vec3 tp, tr, tmp;\n"
-			"varying float shading;\n"
-			"void main() {\n"
-			"  gl_FragColor = vec4(color1.r * shading, color1.g * shading, color1.b * shading, color1.a);\n"
-			"  if (tp.x < tr.x || tp.y < tr.y || tp.z < tr.z)\n"
-			"    gl_FragColor = color2;\n"
-			"}\n";
-
-		GLuint vs = glCreateShader(GL_VERTEX_SHADER);
-		glShaderSource(vs, 1, (const GLchar**)&vs_source, NULL);
-		glCompileShader(vs);
-
-		GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
-		glShaderSource(fs, 1, (const GLchar**)&fs_source, NULL);
-		glCompileShader(fs);
-
-		GLuint edgeshader_prog = glCreateProgram();
-		glAttachShader(edgeshader_prog, vs);
-		glAttachShader(edgeshader_prog, fs);
-		glLinkProgram(edgeshader_prog);
-
-		shaderinfo[0] = edgeshader_prog;
-		shaderinfo[1] = glGetUniformLocation(edgeshader_prog, "color1");
-		shaderinfo[2] = glGetUniformLocation(edgeshader_prog, "color2");
-		shaderinfo[3] = glGetAttribLocation(edgeshader_prog, "trig");
-		shaderinfo[4] = glGetAttribLocation(edgeshader_prog, "pos_b");
-		shaderinfo[5] = glGetAttribLocation(edgeshader_prog, "pos_c");
-		shaderinfo[6] = glGetAttribLocation(edgeshader_prog, "mask");
-		shaderinfo[7] = glGetUniformLocation(edgeshader_prog, "xscale");
-		shaderinfo[8] = glGetUniformLocation(edgeshader_prog, "yscale");
-
-		GLenum err = glGetError();
-		if (err != GL_NO_ERROR) {
-			fprintf(stderr, "OpenGL Error: %s\n", gluErrorString(err));
-		}
-
-		GLint status;
-		glGetProgramiv(edgeshader_prog, GL_LINK_STATUS, &status);
-		if (status == GL_FALSE) {
-			int loglen;
-			char logbuffer[1000];
-			glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
-			fprintf(stderr, "OpenGL Program Linker Error:\n%.*s", loglen, logbuffer);
-		} else {
-			int loglen;
-			char logbuffer[1000];
-			glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
-			if (loglen > 0) {
-				fprintf(stderr, "OpenGL Program Link OK:\n%.*s", loglen, logbuffer);
-			}
-			glValidateProgram(edgeshader_prog);
-			glGetProgramInfoLog(edgeshader_prog, sizeof(logbuffer), &loglen, logbuffer);
-			if (loglen > 0) {
-				fprintf(stderr, "OpenGL Program Validation results:\n%.*s", loglen, logbuffer);
-			}
-		}
-	}
-#endif /* ENABLE_OPENCSG */
-}
-
-#ifdef ENABLE_OPENCSG
-void GLView::display_opencsg_warning()
-{
-	OpenCSGWarningDialog *dialog = new OpenCSGWarningDialog(this);
-
-	QString message;
-	if (this->is_opencsg_capable) {
-		message += "Warning: You may experience OpenCSG rendering errors.\n\n";
-	}
-	else {
-		message += "Warning: Missing OpenGL capabilities for OpenCSG - OpenCSG has been disabled.\n\n";
-		dialog->enableOpenCSGBox->hide();
-	}
-	message += "It is highly recommended to use OpenSCAD on a system with "
-		"OpenGL 2.0 or later.\n"
-		"Your renderer information is as follows:\n";
-	QString rendererinfo;
-	rendererinfo.sprintf("GLEW version %s\n"
-											 "%s (%s)\n"
-											 "OpenGL version %s\n",
-											 glewGetString(GLEW_VERSION),
-											 glGetString(GL_RENDERER), glGetString(GL_VENDOR),
-											 glGetString(GL_VERSION));
-	message += rendererinfo;
-
-	dialog->setText(message);
-	dialog->enableOpenCSGBox->setChecked(Preferences::inst()->getValue("advanced/enable_opencsg_opengl1x").toBool());
-	dialog->exec();
-
-	opencsg_support = this->is_opencsg_capable && Preferences::inst()->getValue("advanced/enable_opencsg_opengl1x").toBool();
-}
-#endif
-
-void GLView::resizeGL(int w, int h)
-{
-#ifdef ENABLE_OPENCSG
-	shaderinfo[9] = w;
-	shaderinfo[10] = h;
-#endif
-	glViewport(0, 0, w, h);
-	w_h_ratio = sqrt((double)w / (double)h);
-
-	setupPerspective();
-}
-
-void GLView::setupPerspective()
-{
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glFrustum(-w_h_ratio, +w_h_ratio, -(1/w_h_ratio), +(1/w_h_ratio), +10.0, +FAR_FAR_AWAY);
-	gluLookAt(0.0, -viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
-}
-
-void GLView::setupOrtho(double distance, bool offset)
-{
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	if(offset)
-		glTranslated(-0.8, -0.8, 0);
-	double l = distance/10;
-	glOrtho(-w_h_ratio*l, +w_h_ratio*l,
-			-(1/w_h_ratio)*l, +(1/w_h_ratio)*l,
-			-FAR_FAR_AWAY, +FAR_FAR_AWAY);
-	gluLookAt(0.0, -viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
-}
-
-void GLView::paintGL()
-{
-	glEnable(GL_LIGHTING);
-
-	if (orthomode) setupOrtho(viewer_distance);
-	else setupPerspective();
-
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-
-	Color4f bgcol = RenderSettings::inst()->color(RenderSettings::BACKGROUND_COLOR);
-	glClearColor(bgcol[0], bgcol[1], bgcol[2], 0.0);
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
-	glRotated(object_rot_x, 1.0, 0.0, 0.0);
-	glRotated(object_rot_y, 0.0, 1.0, 0.0);
-	glRotated(object_rot_z, 0.0, 0.0, 1.0);
-
-  // FIXME: Crosshairs and axes are lighted, this doesn't make sense and causes them
-  // to change color based on view orientation.
-	if (showcrosshairs)
-	{
-		glLineWidth(3);
-		Color4f col = RenderSettings::inst()->color(RenderSettings::CROSSHAIR_COLOR);
-		glColor3f(col[0], col[1], col[2]);
-		glBegin(GL_LINES);
-		for (double xf = -1; xf <= +1; xf += 2)
-		for (double yf = -1; yf <= +1; yf += 2) {
-			double vd = viewer_distance/20;
-			glVertex3d(-xf*vd, -yf*vd, -vd);
-			glVertex3d(+xf*vd, +yf*vd, +vd);
-		}
-		glEnd();
-	}
-
-	glTranslated(object_trans_x, object_trans_y, object_trans_z);
-
-	// Large gray axis cross inline with the model
-  // FIXME: This is always gray - adjust color to keep contrast with background
-	if (showaxes)
-	{
-		glLineWidth(1);
-		glColor3d(0.5, 0.5, 0.5);
-		glBegin(GL_LINES);
-		double l = viewer_distance/10;
-		glVertex3d(-l, 0, 0);
-		glVertex3d(+l, 0, 0);
-		glVertex3d(0, -l, 0);
-		glVertex3d(0, +l, 0);
-		glVertex3d(0, 0, -l);
-		glVertex3d(0, 0, +l);
-		glEnd();
-	}
-
-	glDepthFunc(GL_LESS);
-	glCullFace(GL_BACK);
-	glDisable(GL_CULL_FACE);
-
-	glLineWidth(2);
-	glColor3d(1.0, 0.0, 0.0);
-
-	if (this->renderer) {
-#if defined(ENABLE_MDI) && defined(ENABLE_OPENCSG)
-		// FIXME: This belongs in the OpenCSG renderer, but it doesn't know about this ID yet
-		OpenCSG::setContext(this->opencsg_id);
-#endif
-		this->renderer->draw(showfaces, showedges);
-	}
-
-	// Small axis cross in the lower left corner
-	if (showaxes)
-	{
-		glDepthFunc(GL_ALWAYS);
-
-		setupOrtho(1000,true);
-
-		glMatrixMode(GL_MODELVIEW);
-		glLoadIdentity();
-		glRotated(object_rot_x, 1.0, 0.0, 0.0);
-		glRotated(object_rot_y, 0.0, 1.0, 0.0);
-		glRotated(object_rot_z, 0.0, 0.0, 1.0);
-
-		glLineWidth(1);
-		glBegin(GL_LINES);
-		glColor3d(1.0, 0.0, 0.0);
-		glVertex3d(0, 0, 0); glVertex3d(10, 0, 0);
-		glColor3d(0.0, 1.0, 0.0);
-		glVertex3d(0, 0, 0); glVertex3d(0, 10, 0);
-		glColor3d(0.0, 0.0, 1.0);
-		glVertex3d(0, 0, 0); glVertex3d(0, 0, 10);
-		glEnd();
-
-		GLdouble mat_model[16];
-		glGetDoublev(GL_MODELVIEW_MATRIX, mat_model);
-
-		GLdouble mat_proj[16];
-		glGetDoublev(GL_PROJECTION_MATRIX, mat_proj);
-
-		GLint viewport[4];
-		glGetIntegerv(GL_VIEWPORT, viewport);
-
-		GLdouble xlabel_x, xlabel_y, xlabel_z;
-		gluProject(12, 0, 0, mat_model, mat_proj, viewport, &xlabel_x, &xlabel_y, &xlabel_z);
-		xlabel_x = round(xlabel_x); xlabel_y = round(xlabel_y);
-
-		GLdouble ylabel_x, ylabel_y, ylabel_z;
-		gluProject(0, 12, 0, mat_model, mat_proj, viewport, &ylabel_x, &ylabel_y, &ylabel_z);
-		ylabel_x = round(ylabel_x); ylabel_y = round(ylabel_y);
-
-		GLdouble zlabel_x, zlabel_y, zlabel_z;
-		gluProject(0, 0, 12, mat_model, mat_proj, viewport, &zlabel_x, &zlabel_y, &zlabel_z);
-		zlabel_x = round(zlabel_x); zlabel_y = round(zlabel_y);
-
-		glMatrixMode(GL_PROJECTION);
-		glLoadIdentity();
-		glTranslated(-1, -1, 0);
-		glScaled(2.0/viewport[2], 2.0/viewport[3], 1);
-
-		glMatrixMode(GL_MODELVIEW);
-		glLoadIdentity();
-
-		// FIXME: This was an attempt to keep contrast with background, but is suboptimal
-		// (e.g. nearly invisible against a gray background).
-//		int r,g,b;
-//		r=g=b=0;
-//		bgcol.getRgb(&r, &g, &b);
-//		glColor3f((255.0f-r)/255.0f, (255.0f-g)/255.0f, (255.0f-b)/255.0f);
-		glColor3f(0.0f, 0.0f, 0.0f);
-		glBegin(GL_LINES);
-		// X Label
-		glVertex3d(xlabel_x-3, xlabel_y-3, 0); glVertex3d(xlabel_x+3, xlabel_y+3, 0);
-		glVertex3d(xlabel_x-3, xlabel_y+3, 0); glVertex3d(xlabel_x+3, xlabel_y-3, 0);
-		// Y Label
-		glVertex3d(ylabel_x-3, ylabel_y-3, 0); glVertex3d(ylabel_x+3, ylabel_y+3, 0);
-		glVertex3d(ylabel_x-3, ylabel_y+3, 0); glVertex3d(ylabel_x, ylabel_y, 0);
-		// Z Label
-		glVertex3d(zlabel_x-3, zlabel_y-3, 0); glVertex3d(zlabel_x+3, zlabel_y-3, 0);
-		glVertex3d(zlabel_x-3, zlabel_y+3, 0); glVertex3d(zlabel_x+3, zlabel_y+3, 0);
-		glVertex3d(zlabel_x-3, zlabel_y-3, 0); glVertex3d(zlabel_x+3, zlabel_y+3, 0);
-		glEnd();
-
-		//Restore perspective for next paint
-		if(!orthomode)
-			setupPerspective();
-	}
-
-	if (statusLabel) {
-		QString msg;
-		msg.sprintf("Viewport: translate = [ %.2f %.2f %.2f ], rotate = [ %.2f %.2f %.2f ], distance = %.2f",
-			-object_trans_x, -object_trans_y, -object_trans_z,
-			fmodf(360 - object_rot_x + 90, 360), fmodf(360 - object_rot_y, 360), fmodf(360 - object_rot_z, 360), viewer_distance);
-		statusLabel->setText(msg);
-	}
-
-	if (running_under_wine) swapBuffers();
-}
-
-void GLView::keyPressEvent(QKeyEvent *event)
-{
-	if (event->key() == Qt::Key_Plus) {
-		viewer_distance *= 0.9;
-		updateGL();
-		return;
-	}
-	if (event->key() == Qt::Key_Minus) {
-		viewer_distance /= 0.9;
-		updateGL();
-		return;
-	}
-}
-
-void GLView::wheelEvent(QWheelEvent *event)
-{
-	viewer_distance *= pow(0.9, event->delta() / 120.0);
-	updateGL();
-}
-
-void GLView::mousePressEvent(QMouseEvent *event)
-{
-	mouse_drag_active = true;
-	last_mouse = event->globalPos();
-}
-
-void GLView::normalizeAngle(GLdouble& angle)
-{
-	while(angle < 0)
-		angle += 360;
-	while(angle > 360)
-		angle -= 360;
-}
-
-void GLView::mouseMoveEvent(QMouseEvent *event)
-{
-	QPoint this_mouse = event->globalPos();
-	double dx = (this_mouse.x()-last_mouse.x()) * 0.7;
-	double dy = (this_mouse.y()-last_mouse.y()) * 0.7;
-	if (mouse_drag_active) {
-		if (event->buttons() & Qt::LeftButton
-#ifdef Q_WS_MAC
-				&& !(event->modifiers() & Qt::MetaModifier)
-#endif
-			) {
-			// Left button rotates in xz, Shift-left rotates in xy
-			// On Mac, Ctrl-Left is handled as right button on other platforms
-			object_rot_x += dy;
-			if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) != 0)
-				object_rot_y += dx;
-			else
-				object_rot_z += dx;
-
-			normalizeAngle(object_rot_x);
-			normalizeAngle(object_rot_y);
-			normalizeAngle(object_rot_z);
-		} else {
-			// Right button pans in the xz plane
-			// Middle button pans in the xy plane
-			// Shift-right and Shift-middle zooms
-			if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) != 0) {
-				viewer_distance += (GLdouble)dy;
-			} else {
-
-      double mx = +(dx) * viewer_distance/1000;
-      double mz = -(dy) * viewer_distance/1000;
-
-			double my = 0;
-#if (QT_VERSION < QT_VERSION_CHECK(4, 7, 0))
-			if (event->buttons() & Qt::MidButton) {
-#else
-			if (event->buttons() & Qt::MiddleButton) {
-#endif
-				my = mz;
-				mz = 0;
-				// actually lock the x-position
-				// (turns out to be easier to use than xy panning)
-				mx = 0;
-			}
-
-			Matrix3d aax, aay, aaz, tm3;
-			aax = Eigen::AngleAxisd(-(object_rot_x/180) * M_PI, Vector3d::UnitX());
-			aay = Eigen::AngleAxisd(-(object_rot_y/180) * M_PI, Vector3d::UnitY());
-			aaz = Eigen::AngleAxisd(-(object_rot_z/180) * M_PI, Vector3d::UnitZ());
-			tm3 = Matrix3d::Identity();
-			tm3 = aaz * (aay * (aax * tm3));
-
-			Matrix4d tm;
-			tm = Matrix4d::Identity();
-			for (int i=0;i<3;i++) for (int j=0;j<3;j++) tm(j,i)=tm3(j,i);
-
-			Matrix4d vec;
-			vec <<
-        0,  0,  0,  mx,
-        0,  0,  0,  my,
-        0,  0,  0,  mz,
-        0,  0,  0,  1
-			;
-      tm = tm * vec;
-      object_trans_x += tm(0,3);
-      object_trans_y += tm(1,3);
-      object_trans_z += tm(2,3);
-			}
-		}
-		updateGL();
-		emit doAnimateUpdate();
-	}
-	last_mouse = this_mouse;
-}
-
-void GLView::mouseReleaseEvent(QMouseEvent*)
-{
-	mouse_drag_active = false;
-	releaseMouse();
-}
diff --git a/src/highlighter.cc b/src/highlighter.cc
index 77d1bb8..391e3a5 100644
--- a/src/highlighter.cc
+++ b/src/highlighter.cc
@@ -32,7 +32,7 @@
 
  setFormat() is very slow. normally this doesnt matter because we
  only highlight a block or two at once. But when OpenSCAD first starts,
- QT automatigically calls 'highlightBlock' on every single textblock in the file
+ QT automagically calls 'highlightBlock' on every single textblock in the file
  even if it's not visible in the window. On a large file (50,000 lines) this
  can take several seconds.
 
@@ -103,9 +103,7 @@
    expected result: it should load in a reasonable amount of time
    action: scroll to bottom, put '=' after last ;
    expected result: there should be a highlight, and a report of syntax error
-   action: comment out the highlighter code from mainwin.cc, recompile,
-    run openscad again on the large file. put '=' after last ;
-   expected result: there should be only a small difference in speed.
+    and it should be almost instantaneous.
 
 8. action: open any file, and hold down 'f5' key to repeatedly reparse
    expected result: no crashing!
@@ -116,6 +114,10 @@
 10. action: type random string of [][][][]()()[][90,3904,00,000]
     expected result: all should be highlighted correctly
 
+11. action: type a single slash (/) or slash-star-star (/x**, remove x)
+     into a blank document.
+    expected result: don't crash esp. on mac
+
 */
 
 #include "highlighter.h"
@@ -134,7 +136,7 @@ Highlighter::Highlighter(QTextDocument *parent)
 	typeformats["keyword"].setForeground(QColor("Green"));
 	typeformats["keyword"].setToolTip("Keyword");
 
-	tokentypes["transform"] << "scale" << "translate" << "rotate" << "multmatrix" << "color" << "projection" << "hull";
+	tokentypes["transform"] << "scale" << "translate" << "rotate" << "multmatrix" << "color" << "projection" << "hull" << "resize";
 	typeformats["transform"].setForeground(QColor("Indigo"));
 
 	tokentypes["csgop"]	<< "union" << "intersection" << "difference" << "render";
@@ -164,7 +166,7 @@ Highlighter::Highlighter(QTextDocument *parent)
 	tokentypes["bool"] << "true" << "false";
 	typeformats["bool"].setForeground(QColor("DarkRed"));
 
-	// Put each tokens into single QHash, mapped to it's format
+	// Put each token into single QHash, mapped to it's format
 	QList<QString>::iterator ki;
 	QList<QString> toktypes = tokentypes.keys();
 	for ( ki=toktypes.begin(); ki!=toktypes.end(); ++ki ) {
@@ -249,12 +251,14 @@ void Highlighter::highlightBlock(const QString &text)
 	//  << ", err:" << errorPos << "," << errorState
 	//  << ", text:'" << text.toStdString() << "'\n";
 
-	// Split the block into pieces and highlight each as appropriate
+	// Split the block into chunks (tokens), based on whitespace,
+	// and then highlight each token as appropriate
 	QString newtext = text;
 	QStringList splitHelpers;
 	QStringList::iterator sh, token;
-	// splitHelpers - so "[a+b]" is treated as "[ a + b ]" and formatted
-	splitHelpers << tokentypes["operator"] << "(" << ")" << "[" << "]" << "," << ":";
+	// splitHelpers - so "{[a+b]}" is treated as " { [ a + b ] } "
+	splitHelpers << tokentypes["operator"] << tokentypes["bracket"]
+	  << tokentypes["curlies"] << ":" << ",";
 	for ( sh = splitHelpers.begin(); sh!=splitHelpers.end(); ++sh ) {
 		newtext = newtext.replace( *sh, " " + *sh + " ");
 	}
@@ -287,21 +291,21 @@ void Highlighter::highlightBlock(const QString &text)
 				state = QUOTE;
 				setFormat(n,1,quoteFormat);
 			} else if (text[n] == '/'){
-				if (text[n+1] == '/'){
+				if ( n+1 < text.size() && text[n+1] == '/'){
 					setFormat(n,text.size(),commentFormat);
 					break;
-				} else if (text[n+1] == '*'){
+				} else if ( n+1 < text.size() && text[n+1] == '*'){
 					setFormat(n++,2,commentFormat);
 					state = COMMENT;
 				}
 			}
 		} else if (state == QUOTE){
 			setFormat(n,1,quoteFormat);
-			if (text[n] == '"' && text[n-1] != '\\')
+			if (text[n] == '"' && n-1 >=0 && text[n-1] != '\\')
 				state = NORMAL;
 		} else if (state == COMMENT){
 			setFormat(n,1,commentFormat);
-			if (text[n] == '*' && text[n+1] == '/'){
+			if (text[n] == '*' && n+1 < text.size() && text[n+1] == '/'){
 				setFormat(++n,1,commentFormat);
 				state = NORMAL;
 			}
diff --git a/src/imageutils-lodepng.cc b/src/imageutils-lodepng.cc
new file mode 100644
index 0000000..cd104d6
--- /dev/null
+++ b/src/imageutils-lodepng.cc
@@ -0,0 +1,17 @@
+#include "imageutils.h"
+#include "lodepng.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <iterator>
+#include <algorithm>
+
+bool write_png(std::ostream &output, unsigned char *pixels, int width, int height)
+{
+	std::vector<unsigned char> dataout;
+	unsigned err = lodepng::encode(dataout, pixels, width, height, LCT_RGBA, 8);
+	if ( err ) return false;
+	output.write( reinterpret_cast<const char *>(&dataout[0]), dataout.size());
+	if ( output.bad() ) std::cerr << "Error writing to ostream\n";
+	return output.good();
+}
diff --git a/src/imageutils-macosx.cc b/src/imageutils-macosx.cc
new file mode 100644
index 0000000..4c7c446
--- /dev/null
+++ b/src/imageutils-macosx.cc
@@ -0,0 +1,98 @@
+#include <ApplicationServices/ApplicationServices.h>
+#include <iostream>
+#include "imageutils.h"
+#include <assert.h>
+
+CGDataConsumerCallbacks dc_callbacks;
+
+size_t write_bytes_to_ostream (void *info,const void *buffer,size_t count)
+{
+	assert( info && buffer );
+	std::ostream *output = (std::ostream *)info;
+	size_t startpos = output->tellp();
+	size_t endpos = startpos;
+	try {
+		output->write( (const char *)buffer, count );
+		endpos = output->tellp();
+	} catch (const std::ios_base::failure& e) {
+		std::cerr << "Error writing to ostream:" << e.what() << "\n";
+	}
+	return (endpos-startpos);
+}
+
+CGDataConsumerRef CGDataConsumerCreateWithOstream(std::ostream &output)
+{
+	dc_callbacks.putBytes = write_bytes_to_ostream;
+	dc_callbacks.releaseConsumer = NULL; // ostream closed by caller of write_png
+	CGDataConsumerRef dc = CGDataConsumerCreate ( (void *)(&output), &dc_callbacks );
+	return dc;
+}
+
+bool write_png(std::ostream &output, unsigned char *pixels, int width, int height)
+{
+  size_t rowBytes = width * 4;
+//  CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+	CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGBitmapInfo bitmapInfo = kCGImageAlphaNoneSkipLast | kCGBitmapByteOrder32Big; // BGRA
+  int bitsPerComponent = 8;
+  CGContextRef contextRef = CGBitmapContextCreate(pixels, width, height, 
+																									bitsPerComponent, rowBytes, 
+                                                  colorSpace, bitmapInfo);
+  if (!contextRef) {
+    std::cerr << "Unable to create CGContextRef.";
+    return false;
+  }
+
+  CGImageRef imageRef = CGBitmapContextCreateImage(contextRef);
+  if (!imageRef) {
+    std::cerr <<  "Unable to create CGImageRef.";
+    return false;
+  }
+
+  CGDataConsumerRef dataconsumer = CGDataConsumerCreateWithOstream(output);
+  /*
+  CFStringRef fname = CFStringCreateWithCString(kCFAllocatorDefault, filename, kCFStringEncodingUTF8);
+  CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
+                                                   fname, kCFURLPOSIXPathStyle, false);
+  if (!fileURL) {
+    std::cerr << "Unable to create file URL ref.";
+    return false;
+  }
+
+	CGDataConsumerRef dataconsumer = CGDataConsumerCreateWithURL(fileURL);
+  */
+
+  CFIndex                 fileImageIndex = 1;
+  CFMutableDictionaryRef  fileDict       = NULL;
+  CFStringRef             fileUTType     = kUTTypePNG;
+  // Create an image destination opaque reference for authoring an image file
+  CGImageDestinationRef imageDest = CGImageDestinationCreateWithDataConsumer(dataconsumer,
+                                                                             fileUTType, 
+                                                                             fileImageIndex, 
+                                                                             fileDict);
+  if (!imageDest) {
+    std::cerr <<  "Unable to create CGImageDestinationRef.";
+    return false;
+  }
+
+  CFIndex capacity = 1;
+  CFMutableDictionaryRef imageProps = 
+    CFDictionaryCreateMutable(kCFAllocatorDefault, 
+                              capacity,
+                              &kCFTypeDictionaryKeyCallBacks,
+                              &kCFTypeDictionaryValueCallBacks);
+  CGImageDestinationAddImage(imageDest, imageRef, imageProps);
+  CGImageDestinationFinalize(imageDest);
+
+  CFRelease(imageDest);
+  CFRelease(dataconsumer);
+  //CFRelease(fileURL);
+  //CFRelease(fname);
+  CFRelease(imageProps);
+  CGColorSpaceRelease(colorSpace);
+  CGImageRelease(imageRef);
+  return true;
+}
+
+
+
diff --git a/src/imageutils.cc b/src/imageutils.cc
new file mode 100644
index 0000000..3e1f3bc
--- /dev/null
+++ b/src/imageutils.cc
@@ -0,0 +1,27 @@
+#include "imageutils.h"
+#include <assert.h>
+#include <string.h>
+#include <fstream>
+
+void flip_image(const unsigned char *src, unsigned char *dst, size_t pixelsize, size_t width, size_t height)
+{
+  assert( src && dst );
+  size_t rowBytes = pixelsize * width;
+  for (size_t i = 0 ; i < height ; i++) {
+    memmove(dst + (height - i - 1) * rowBytes, src + i * rowBytes, rowBytes);
+  }
+}
+
+bool write_png(const char *filename, unsigned char *pixels, int width, int height) {
+  assert( filename && pixels );
+  std::ofstream fstream( filename, std::ios::binary );
+  if (fstream.is_open()) {
+    write_png( fstream, pixels, width, height );
+    fstream.close();
+    return true;
+  } else {
+    std::cerr << "Can't open file " << filename << " for export.";
+    return false;
+  }
+}
+
diff --git a/src/imageutils.h b/src/imageutils.h
new file mode 100644
index 0000000..c9bb8de
--- /dev/null
+++ b/src/imageutils.h
@@ -0,0 +1,11 @@
+#ifndef IMAGEUTILS_H_
+#define IMAGEUTILS_H_
+
+#include <stdlib.h>
+#include <iostream>
+
+bool write_png(const char *filename, unsigned char *pixels, int width, int height);
+bool write_png(std::ostream &output, unsigned char *pixels, int width, int height);
+void flip_image(const unsigned char *src, unsigned char *dst, size_t pixelsize, size_t width, size_t height);
+
+#endif
diff --git a/src/import.cc b/src/import.cc
index 8980448..32d4fed 100644
--- a/src/import.cc
+++ b/src/import.cc
@@ -132,7 +132,9 @@ union stl_facet {
 
 void uint32_byte_swap( uint32_t &x )
 {
-#if defined(__GNUC__) || defined(__clang__)
+#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
+	x = __builtin_bswap32( x );
+#elif defined(__clang__)
 	x = __builtin_bswap32( x );
 #elif defined(_MSC_VER)
 	x = _byteswap_ulong( x );
diff --git a/src/lexer.l b/src/lexer.l
index 63b0047..4dff654 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -225,6 +225,14 @@ void includefile()
     finfo = locate_file((fs::path(filepath) / filename).string());
   }
 
+  if (!exists(finfo) || finfo.empty()) {
+    // deal with some unusual situations with is_absolute() and Wine
+    fs::path fnp( fs::path(filepath) / filename );
+    if (fs::exists( fnp ) && !fs::is_directory( fnp )) {
+      finfo = fnp;
+    }
+  }
+
   if (finfo.empty()) {
     PRINTB("WARNING: Can't find 'include' file '%s'.", filename);
   }
diff --git a/src/linalg.cc b/src/linalg.cc
index 2f368f9..6799055 100644
--- a/src/linalg.cc
+++ b/src/linalg.cc
@@ -46,3 +46,17 @@ bool matrix_contains_nan( const Transform3d &m )
 	return false;
 }
 
+double getBoundingRadius(BoundingBox bbox)
+{
+	// FIXME: For eigen3, we can use bbox.diagonal().norm()/2;
+  double radius = (bbox.max() - bbox.min()).norm() / 2;
+  return radius; // 0;
+}
+
+Vector3d getBoundingCenter(BoundingBox bbox)
+{
+  // FIXME: For eigen3, we can use bbox.center();
+  Vector3d center = (bbox.min() + bbox.max()) / 2;
+  return center; // Vector3d(0,0,0);
+}
+
diff --git a/src/linalg.h b/src/linalg.h
index 48960b7..1f9ed30 100644
--- a/src/linalg.h
+++ b/src/linalg.h
@@ -22,6 +22,9 @@ bool matrix_contains_infinity( const Transform3d &m );
 bool matrix_contains_nan( const Transform3d &m );
 
 BoundingBox operator*(const Transform3d &m, const BoundingBox &box);
+Vector3d getBoundingCenter(BoundingBox bbox);
+double getBoundingRadius(BoundingBox bbox);
+
 
 class Color4f : public Eigen::Vector4f
 {
diff --git a/src/lodepng.cpp b/src/lodepng.cpp
new file mode 100644
index 0000000..9003168
--- /dev/null
+++ b/src/lodepng.cpp
@@ -0,0 +1,6226 @@
+/*
+LodePNG version 20130128
+
+Copyright (c) 2005-2013 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+/*
+The manual and changelog are in the header file "lodepng.h"
+Rename this file to lodepng.cpp to use it for C++, or to lodepng.c to use it for C.
+*/
+
+#include "lodepng.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef LODEPNG_COMPILE_CPP
+#include <fstream>
+#endif /*LODEPNG_COMPILE_CPP*/
+
+#define VERSION_STRING "20130128"
+
+/*
+This source file is built up in the following large parts. The code sections
+with the "LODEPNG_COMPILE_" #defines divide this up further in an intermixed way.
+-Tools for C and common code for PNG and Zlib
+-C Code for Zlib (huffman, deflate, ...)
+-C Code for PNG (file format chunks, adam7, PNG filters, color conversions, ...)
+-The C++ wrapper around all of the above
+*/
+
+/*The malloc, realloc and free functions defined here with "my" in front of the
+name, so that you can easily change them to others related to your platform in
+this one location if needed. Everything else in the code calls these.*/
+
+static void* mymalloc(size_t size)
+{
+  return malloc(size);
+}
+
+static void* myrealloc(void* ptr, size_t new_size)
+{
+  return realloc(ptr, new_size);
+}
+
+static void myfree(void* ptr)
+{
+  free(ptr);
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* // Tools for C, and common code for PNG and Zlib.                       // */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*
+Often in case of an error a value is assigned to a variable and then it breaks
+out of a loop (to go to the cleanup phase of a function). This macro does that.
+It makes the error handling code shorter and more readable.
+
+Example: if(!uivector_resizev(&frequencies_ll, 286, 0)) ERROR_BREAK(83);
+*/
+#define CERROR_BREAK(errorvar, code)\
+{\
+  errorvar = code;\
+  break;\
+}
+
+/*version of CERROR_BREAK that assumes the common case where the error variable is named "error"*/
+#define ERROR_BREAK(code) CERROR_BREAK(error, code)
+
+/*Set error var to the error code, and return it.*/
+#define CERROR_RETURN_ERROR(errorvar, code)\
+{\
+  errorvar = code;\
+  return code;\
+}
+
+/*Try the code, if it returns error, also return the error.*/
+#define CERROR_TRY_RETURN(call)\
+{\
+  unsigned error = call;\
+  if(error) return error;\
+}
+
+/*
+About uivector, ucvector and string:
+-All of them wrap dynamic arrays or text strings in a similar way.
+-LodePNG was originally written in C++. The vectors replace the std::vectors that were used in the C++ version.
+-The string tools are made to avoid problems with compilers that declare things like strncat as deprecated.
+-They're not used in the interface, only internally in this file as static functions.
+-As with many other structs in this file, the init and cleanup functions serve as ctor and dtor.
+*/
+
+#ifdef LODEPNG_COMPILE_ZLIB
+/*dynamic vector of unsigned ints*/
+typedef struct uivector
+{
+  unsigned* data;
+  size_t size; /*size in number of unsigned longs*/
+  size_t allocsize; /*allocated size in bytes*/
+} uivector;
+
+static void uivector_cleanup(void* p)
+{
+  ((uivector*)p)->size = ((uivector*)p)->allocsize = 0;
+  myfree(((uivector*)p)->data);
+  ((uivector*)p)->data = NULL;
+}
+
+/*returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned uivector_resize(uivector* p, size_t size)
+{
+  if(size * sizeof(unsigned) > p->allocsize)
+  {
+    size_t newsize = size * sizeof(unsigned) * 2;
+    void* data = myrealloc(p->data, newsize);
+    if(data)
+    {
+      p->allocsize = newsize;
+      p->data = (unsigned*)data;
+      p->size = size;
+    }
+    else return 0;
+  }
+  else p->size = size;
+  return 1;
+}
+
+/*resize and give all new elements the value*/
+static unsigned uivector_resizev(uivector* p, size_t size, unsigned value)
+{
+  size_t oldsize = p->size, i;
+  if(!uivector_resize(p, size)) return 0;
+  for(i = oldsize; i < size; i++) p->data[i] = value;
+  return 1;
+}
+
+static void uivector_init(uivector* p)
+{
+  p->data = NULL;
+  p->size = p->allocsize = 0;
+}
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned uivector_push_back(uivector* p, unsigned c)
+{
+  if(!uivector_resize(p, p->size + 1)) return 0;
+  p->data[p->size - 1] = c;
+  return 1;
+}
+
+/*copy q to p, returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned uivector_copy(uivector* p, const uivector* q)
+{
+  size_t i;
+  if(!uivector_resize(p, q->size)) return 0;
+  for(i = 0; i < q->size; i++) p->data[i] = q->data[i];
+  return 1;
+}
+
+static void uivector_swap(uivector* p, uivector* q)
+{
+  size_t tmp;
+  unsigned* tmpp;
+  tmp = p->size; p->size = q->size; q->size = tmp;
+  tmp = p->allocsize; p->allocsize = q->allocsize; q->allocsize = tmp;
+  tmpp = p->data; p->data = q->data; q->data = tmpp;
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+#endif /*LODEPNG_COMPILE_ZLIB*/
+
+/* /////////////////////////////////////////////////////////////////////////// */
+
+/*dynamic vector of unsigned chars*/
+typedef struct ucvector
+{
+  unsigned char* data;
+  size_t size; /*used size*/
+  size_t allocsize; /*allocated size*/
+} ucvector;
+
+/*returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned ucvector_resize(ucvector* p, size_t size)
+{
+  if(size * sizeof(unsigned char) > p->allocsize)
+  {
+    size_t newsize = size * sizeof(unsigned char) * 2;
+    void* data = myrealloc(p->data, newsize);
+    if(data)
+    {
+      p->allocsize = newsize;
+      p->data = (unsigned char*)data;
+      p->size = size;
+    }
+    else return 0; /*error: not enough memory*/
+  }
+  else p->size = size;
+  return 1;
+}
+
+#ifdef LODEPNG_COMPILE_PNG
+
+static void ucvector_cleanup(void* p)
+{
+  ((ucvector*)p)->size = ((ucvector*)p)->allocsize = 0;
+  myfree(((ucvector*)p)->data);
+  ((ucvector*)p)->data = NULL;
+}
+
+static void ucvector_init(ucvector* p)
+{
+  p->data = NULL;
+  p->size = p->allocsize = 0;
+}
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*resize and give all new elements the value*/
+static unsigned ucvector_resizev(ucvector* p, size_t size, unsigned char value)
+{
+  size_t oldsize = p->size, i;
+  if(!ucvector_resize(p, size)) return 0;
+  for(i = oldsize; i < size; i++) p->data[i] = value;
+  return 1;
+}
+#endif /*LODEPNG_COMPILE_DECODER*/
+#endif /*LODEPNG_COMPILE_PNG*/
+
+#ifdef LODEPNG_COMPILE_ZLIB
+/*you can both convert from vector to buffer&size and vica versa. If you use
+init_buffer to take over a buffer and size, it is not needed to use cleanup*/
+static void ucvector_init_buffer(ucvector* p, unsigned char* buffer, size_t size)
+{
+  p->data = buffer;
+  p->allocsize = p->size = size;
+}
+#endif /*LODEPNG_COMPILE_ZLIB*/
+
+#if (defined(LODEPNG_COMPILE_PNG) && defined(LODEPNG_COMPILE_ANCILLARY_CHUNKS)) || defined(LODEPNG_COMPILE_ENCODER)
+/*returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned ucvector_push_back(ucvector* p, unsigned char c)
+{
+  if(!ucvector_resize(p, p->size + 1)) return 0;
+  p->data[p->size - 1] = c;
+  return 1;
+}
+#endif /*defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_ENCODER)*/
+
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_PNG
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+/*returns 1 if success, 0 if failure ==> nothing done*/
+static unsigned string_resize(char** out, size_t size)
+{
+  char* data = (char*)myrealloc(*out, size + 1);
+  if(data)
+  {
+    data[size] = 0; /*null termination char*/
+    *out = data;
+  }
+  return data != 0;
+}
+
+/*init a {char*, size_t} pair for use as string*/
+static void string_init(char** out)
+{
+  *out = NULL;
+  string_resize(out, 0);
+}
+
+/*free the above pair again*/
+static void string_cleanup(char** out)
+{
+  myfree(*out);
+  *out = NULL;
+}
+
+static void string_set(char** out, const char* in)
+{
+  size_t insize = strlen(in), i = 0;
+  if(string_resize(out, insize))
+  {
+    for(i = 0; i < insize; i++)
+    {
+      (*out)[i] = in[i];
+    }
+  }
+}
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+#endif /*LODEPNG_COMPILE_PNG*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+unsigned lodepng_read32bitInt(const unsigned char* buffer)
+{
+  return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
+}
+
+#if defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_ENCODER)
+/*buffer must have at least 4 allocated bytes available*/
+static void lodepng_set32bitInt(unsigned char* buffer, unsigned value)
+{
+  buffer[0] = (unsigned char)((value >> 24) & 0xff);
+  buffer[1] = (unsigned char)((value >> 16) & 0xff);
+  buffer[2] = (unsigned char)((value >>  8) & 0xff);
+  buffer[3] = (unsigned char)((value      ) & 0xff);
+}
+#endif /*defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_ENCODER)*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+static void lodepng_add32bitInt(ucvector* buffer, unsigned value)
+{
+  ucvector_resize(buffer, buffer->size + 4); /*todo: give error if resize failed*/
+  lodepng_set32bitInt(&buffer->data[buffer->size - 4], value);
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / File IO                                                                / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_DISK
+
+unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
+{
+  FILE* file;
+  long size;
+
+  /*provide some proper output values if error will happen*/
+  *out = 0;
+  *outsize = 0;
+
+  file = fopen(filename, "rb");
+  if(!file) return 78;
+
+  /*get filesize:*/
+  fseek(file , 0 , SEEK_END);
+  size = ftell(file);
+  rewind(file);
+
+  /*read contents of the file into the vector*/
+  *outsize = 0;
+  *out = (unsigned char*)mymalloc((size_t)size);
+  if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);
+
+  fclose(file);
+  if(!(*out) && size) return 83; /*the above malloc failed*/
+  return 0;
+}
+
+/*write given buffer to the file, overwriting the file, it doesn't append to it.*/
+unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename)
+{
+  FILE* file;
+  file = fopen(filename, "wb" );
+  if(!file) return 79;
+  fwrite((char*)buffer , 1 , buffersize, file);
+  fclose(file);
+  return 0;
+}
+
+#endif /*LODEPNG_COMPILE_DISK*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* // End of common code and tools. Begin of Zlib related code.            // */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_ZLIB
+#ifdef LODEPNG_COMPILE_ENCODER
+/*TODO: this ignores potential out of memory errors*/
+static void addBitToStream(size_t* bitpointer, ucvector* bitstream, unsigned char bit)
+{
+  /*add a new byte at the end*/
+  if((*bitpointer) % 8 == 0) ucvector_push_back(bitstream, (unsigned char)0);
+  /*earlier bit of huffman code is in a lesser significant bit of an earlier byte*/
+  (bitstream->data[bitstream->size - 1]) |= (bit << ((*bitpointer) & 0x7));
+  (*bitpointer)++;
+}
+
+static void addBitsToStream(size_t* bitpointer, ucvector* bitstream, unsigned value, size_t nbits)
+{
+  size_t i;
+  for(i = 0; i < nbits; i++) addBitToStream(bitpointer, bitstream, (unsigned char)((value >> i) & 1));
+}
+
+static void addBitsToStreamReversed(size_t* bitpointer, ucvector* bitstream, unsigned value, size_t nbits)
+{
+  size_t i;
+  for(i = 0; i < nbits; i++) addBitToStream(bitpointer, bitstream, (unsigned char)((value >> (nbits - 1 - i)) & 1));
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+#define READBIT(bitpointer, bitstream) ((bitstream[bitpointer >> 3] >> (bitpointer & 0x7)) & (unsigned char)1)
+
+static unsigned char readBitFromStream(size_t* bitpointer, const unsigned char* bitstream)
+{
+  unsigned char result = (unsigned char)(READBIT(*bitpointer, bitstream));
+  (*bitpointer)++;
+  return result;
+}
+
+static unsigned readBitsFromStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
+{
+  unsigned result = 0, i;
+  for(i = 0; i < nbits; i++)
+  {
+    result += ((unsigned)READBIT(*bitpointer, bitstream)) << i;
+    (*bitpointer)++;
+  }
+  return result;
+}
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Deflate - Huffman                                                      / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#define FIRST_LENGTH_CODE_INDEX 257
+#define LAST_LENGTH_CODE_INDEX 285
+/*256 literals, the end code, some length codes, and 2 unused codes*/
+#define NUM_DEFLATE_CODE_SYMBOLS 288
+/*the distance codes have their own symbols, 30 used, 2 unused*/
+#define NUM_DISTANCE_SYMBOLS 32
+/*the code length codes. 0-15: code lengths, 16: copy previous 3-6 times, 17: 3-10 zeros, 18: 11-138 zeros*/
+#define NUM_CODE_LENGTH_CODES 19
+
+/*the base lengths represented by codes 257-285*/
+static const unsigned LENGTHBASE[29]
+  = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
+     67, 83, 99, 115, 131, 163, 195, 227, 258};
+
+/*the extra bits used by codes 257-285 (added to base length)*/
+static const unsigned LENGTHEXTRA[29]
+  = {0, 0, 0, 0, 0, 0, 0,  0,  1,  1,  1,  1,  2,  2,  2,  2,  3,  3,  3,  3,
+      4,  4,  4,   4,   5,   5,   5,   5,   0};
+
+/*the base backwards distances (the bits of distance codes appear after length codes and use their own huffman tree)*/
+static const unsigned DISTANCEBASE[30]
+  = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
+     769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577};
+
+/*the extra bits of backwards distances (added to base)*/
+static const unsigned DISTANCEEXTRA[30]
+  = {0, 0, 0, 0, 1, 1, 2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7,   8,
+       8,    9,    9,   10,   10,   11,   11,   12,    12,    13,    13};
+
+/*the order in which "code length alphabet code lengths" are stored, out of this
+the huffman tree of the dynamic huffman tree lengths is generated*/
+static const unsigned CLCL_ORDER[NUM_CODE_LENGTH_CODES]
+  = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*
+Huffman tree struct, containing multiple representations of the tree
+*/
+typedef struct HuffmanTree
+{
+  unsigned* tree2d;
+  unsigned* tree1d;
+  unsigned* lengths; /*the lengths of the codes of the 1d-tree*/
+  unsigned maxbitlen; /*maximum number of bits a single code can get*/
+  unsigned numcodes; /*number of symbols in the alphabet = number of codes*/
+} HuffmanTree;
+
+/*function used for debug purposes to draw the tree in ascii art with C++*/
+/*#include <iostream>
+static void HuffmanTree_draw(HuffmanTree* tree)
+{
+  std::cout << "tree. length: " << tree->numcodes << " maxbitlen: " << tree->maxbitlen << std::endl;
+  for(size_t i = 0; i < tree->tree1d.size; i++)
+  {
+    if(tree->lengths.data[i])
+      std::cout << i << " " << tree->tree1d.data[i] << " " << tree->lengths.data[i] << std::endl;
+  }
+  std::cout << std::endl;
+}*/
+
+static void HuffmanTree_init(HuffmanTree* tree)
+{
+  tree->tree2d = 0;
+  tree->tree1d = 0;
+  tree->lengths = 0;
+}
+
+static void HuffmanTree_cleanup(HuffmanTree* tree)
+{
+  myfree(tree->tree2d);
+  myfree(tree->tree1d);
+  myfree(tree->lengths);
+}
+
+/*the tree representation used by the decoder. return value is error*/
+static unsigned HuffmanTree_make2DTree(HuffmanTree* tree)
+{
+  unsigned nodefilled = 0; /*up to which node it is filled*/
+  unsigned treepos = 0; /*position in the tree (1 of the numcodes columns)*/
+  unsigned n, i;
+
+  tree->tree2d = (unsigned*)mymalloc(tree->numcodes * 2 * sizeof(unsigned));
+  if(!tree->tree2d) return 83; /*alloc fail*/
+
+  /*
+  convert tree1d[] to tree2d[][]. In the 2D array, a value of 32767 means
+  uninited, a value >= numcodes is an address to another bit, a value < numcodes
+  is a code. The 2 rows are the 2 possible bit values (0 or 1), there are as
+  many columns as codes - 1.
+  A good huffmann tree has N * 2 - 1 nodes, of which N - 1 are internal nodes.
+  Here, the internal nodes are stored (what their 0 and 1 option point to).
+  There is only memory for such good tree currently, if there are more nodes
+  (due to too long length codes), error 55 will happen
+  */
+  for(n = 0; n < tree->numcodes * 2; n++)
+  {
+    tree->tree2d[n] = 32767; /*32767 here means the tree2d isn't filled there yet*/
+  }
+
+  for(n = 0; n < tree->numcodes; n++) /*the codes*/
+  {
+    for(i = 0; i < tree->lengths[n]; i++) /*the bits for this code*/
+    {
+      unsigned char bit = (unsigned char)((tree->tree1d[n] >> (tree->lengths[n] - i - 1)) & 1);
+      if(treepos > tree->numcodes - 2) return 55; /*oversubscribed, see comment in lodepng_error_text*/
+      if(tree->tree2d[2 * treepos + bit] == 32767) /*not yet filled in*/
+      {
+        if(i + 1 == tree->lengths[n]) /*last bit*/
+        {
+          tree->tree2d[2 * treepos + bit] = n; /*put the current code in it*/
+          treepos = 0;
+        }
+        else
+        {
+          /*put address of the next step in here, first that address has to be found of course
+          (it's just nodefilled + 1)...*/
+          nodefilled++;
+          /*addresses encoded with numcodes added to it*/
+          tree->tree2d[2 * treepos + bit] = nodefilled + tree->numcodes;
+          treepos = nodefilled;
+        }
+      }
+      else treepos = tree->tree2d[2 * treepos + bit] - tree->numcodes;
+    }
+  }
+
+  for(n = 0;  n < tree->numcodes * 2; n++)
+  {
+    if(tree->tree2d[n] == 32767) tree->tree2d[n] = 0; /*remove possible remaining 32767's*/
+  }
+
+  return 0;
+}
+
+/*
+Second step for the ...makeFromLengths and ...makeFromFrequencies functions.
+numcodes, lengths and maxbitlen must already be filled in correctly. return
+value is error.
+*/
+static unsigned HuffmanTree_makeFromLengths2(HuffmanTree* tree)
+{
+  uivector blcount;
+  uivector nextcode;
+  unsigned bits, n, error = 0;
+
+  uivector_init(&blcount);
+  uivector_init(&nextcode);
+
+  tree->tree1d = (unsigned*)mymalloc(tree->numcodes * sizeof(unsigned));
+  if(!tree->tree1d) error = 83; /*alloc fail*/
+
+  if(!uivector_resizev(&blcount, tree->maxbitlen + 1, 0)
+  || !uivector_resizev(&nextcode, tree->maxbitlen + 1, 0))
+    error = 83; /*alloc fail*/
+
+  if(!error)
+  {
+    /*step 1: count number of instances of each code length*/
+    for(bits = 0; bits < tree->numcodes; bits++) blcount.data[tree->lengths[bits]]++;
+    /*step 2: generate the nextcode values*/
+    for(bits = 1; bits <= tree->maxbitlen; bits++)
+    {
+      nextcode.data[bits] = (nextcode.data[bits - 1] + blcount.data[bits - 1]) << 1;
+    }
+    /*step 3: generate all the codes*/
+    for(n = 0; n < tree->numcodes; n++)
+    {
+      if(tree->lengths[n] != 0) tree->tree1d[n] = nextcode.data[tree->lengths[n]]++;
+    }
+  }
+
+  uivector_cleanup(&blcount);
+  uivector_cleanup(&nextcode);
+
+  if(!error) return HuffmanTree_make2DTree(tree);
+  else return error;
+}
+
+/*
+given the code lengths (as stored in the PNG file), generate the tree as defined
+by Deflate. maxbitlen is the maximum bits that a code in the tree can have.
+return value is error.
+*/
+static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen,
+                                            size_t numcodes, unsigned maxbitlen)
+{
+  unsigned i;
+  tree->lengths = (unsigned*)mymalloc(numcodes * sizeof(unsigned));
+  if(!tree->lengths) return 83; /*alloc fail*/
+  for(i = 0; i < numcodes; i++) tree->lengths[i] = bitlen[i];
+  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
+  tree->maxbitlen = maxbitlen;
+  return HuffmanTree_makeFromLengths2(tree);
+}
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+/*
+A coin, this is the terminology used for the package-merge algorithm and the
+coin collector's problem. This is used to generate the huffman tree.
+A coin can be multiple coins (when they're merged)
+*/
+typedef struct Coin
+{
+  uivector symbols;
+  float weight; /*the sum of all weights in this coin*/
+} Coin;
+
+static void coin_init(Coin* c)
+{
+  uivector_init(&c->symbols);
+}
+
+/*argument c is void* so that this dtor can be given as function pointer to the vector resize function*/
+static void coin_cleanup(void* c)
+{
+  uivector_cleanup(&((Coin*)c)->symbols);
+}
+
+static void coin_copy(Coin* c1, const Coin* c2)
+{
+  c1->weight = c2->weight;
+  uivector_copy(&c1->symbols, &c2->symbols);
+}
+
+static void add_coins(Coin* c1, const Coin* c2)
+{
+  size_t i;
+  for(i = 0; i < c2->symbols.size; i++) uivector_push_back(&c1->symbols, c2->symbols.data[i]);
+  c1->weight += c2->weight;
+}
+
+static void init_coins(Coin* coins, size_t num)
+{
+  size_t i;
+  for(i = 0; i < num; i++) coin_init(&coins[i]);
+}
+
+static void cleanup_coins(Coin* coins, size_t num)
+{
+  size_t i;
+  for(i = 0; i < num; i++) coin_cleanup(&coins[i]);
+}
+
+/*
+This uses a simple combsort to sort the data. This function is not critical for
+overall encoding speed and the data amount isn't that large.
+*/
+static void sort_coins(Coin* data, size_t amount)
+{
+  size_t gap = amount;
+  unsigned char swapped = 0;
+  while((gap > 1) || swapped)
+  {
+    size_t i;
+    gap = (gap * 10) / 13; /*shrink factor 1.3*/
+    if(gap == 9 || gap == 10) gap = 11; /*combsort11*/
+    if(gap < 1) gap = 1;
+    swapped = 0;
+    for(i = 0; i < amount - gap; i++)
+    {
+      size_t j = i + gap;
+      if(data[j].weight < data[i].weight)
+      {
+        float temp = data[j].weight; data[j].weight = data[i].weight; data[i].weight = temp;
+        uivector_swap(&data[i].symbols, &data[j].symbols);
+        swapped = 1;
+      }
+    }
+  }
+}
+
+static unsigned append_symbol_coins(Coin* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
+{
+  unsigned i;
+  unsigned j = 0; /*index of present symbols*/
+  for(i = 0; i < numcodes; i++)
+  {
+    if(frequencies[i] != 0) /*only include symbols that are present*/
+    {
+      coins[j].weight = frequencies[i] / (float)sum;
+      uivector_push_back(&coins[j].symbols, i);
+      j++;
+    }
+  }
+  return 0;
+}
+
+unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies,
+                                      size_t numcodes, unsigned maxbitlen)
+{
+  unsigned i, j;
+  size_t sum = 0, numpresent = 0;
+  unsigned error = 0;
+  Coin* coins; /*the coins of the currently calculated row*/
+  Coin* prev_row; /*the previous row of coins*/
+  unsigned numcoins;
+  unsigned coinmem;
+
+  if(numcodes == 0) return 80; /*error: a tree of 0 symbols is not supposed to be made*/
+
+  for(i = 0; i < numcodes; i++)
+  {
+    if(frequencies[i] > 0)
+    {
+      numpresent++;
+      sum += frequencies[i];
+    }
+  }
+
+  for(i = 0; i < numcodes; i++) lengths[i] = 0;
+
+  /*ensure at least two present symbols. There should be at least one symbol
+  according to RFC 1951 section 3.2.7. To decoders incorrectly require two. To
+  make these work as well ensure there are at least two symbols. The
+  Package-Merge code below also doesn't work correctly if there's only one
+  symbol, it'd give it the theoritical 0 bits but in practice zlib wants 1 bit*/
+  if(numpresent == 0)
+  {
+    lengths[0] = lengths[1] = 1; /*note that for RFC 1951 section 3.2.7, only lengths[0] = 1 is needed*/
+  }
+  else if(numpresent == 1)
+  {
+    for(i = 0; i < numcodes; i++)
+    {
+      if(frequencies[i])
+      {
+        lengths[i] = 1;
+        lengths[i == 0 ? 1 : 0] = 1;
+        break;
+      }
+    }
+  }
+  else
+  {
+    /*Package-Merge algorithm represented by coin collector's problem
+    For every symbol, maxbitlen coins will be created*/
+
+    coinmem = numpresent * 2; /*max amount of coins needed with the current algo*/
+    coins = (Coin*)mymalloc(sizeof(Coin) * coinmem);
+    prev_row = (Coin*)mymalloc(sizeof(Coin) * coinmem);
+    if(!coins || !prev_row) return 83; /*alloc fail*/
+    init_coins(coins, coinmem);
+    init_coins(prev_row, coinmem);
+
+    /*first row, lowest denominator*/
+    error = append_symbol_coins(coins, frequencies, numcodes, sum);
+    numcoins = numpresent;
+    sort_coins(coins, numcoins);
+    if(!error)
+    {
+      unsigned numprev = 0;
+      for(j = 1; j <= maxbitlen && !error; j++) /*each of the remaining rows*/
+      {
+        unsigned tempnum;
+        Coin* tempcoins;
+        /*swap prev_row and coins, and their amounts*/
+        tempcoins = prev_row; prev_row = coins; coins = tempcoins;
+        tempnum = numprev; numprev = numcoins; numcoins = tempnum;
+
+        cleanup_coins(coins, numcoins);
+        init_coins(coins, numcoins);
+
+        numcoins = 0;
+
+        /*fill in the merged coins of the previous row*/
+        for(i = 0; i + 1 < numprev; i += 2)
+        {
+          /*merge prev_row[i] and prev_row[i + 1] into new coin*/
+          Coin* coin = &coins[numcoins++];
+          coin_copy(coin, &prev_row[i]);
+          add_coins(coin, &prev_row[i + 1]);
+        }
+        /*fill in all the original symbols again*/
+        if(j < maxbitlen)
+        {
+          error = append_symbol_coins(coins + numcoins, frequencies, numcodes, sum);
+          numcoins += numpresent;
+        }
+        sort_coins(coins, numcoins);
+      }
+    }
+
+    if(!error)
+    {
+      /*calculate the lenghts of each symbol, as the amount of times a coin of each symbol is used*/
+      for(i = 0; i < numpresent - 1; i++)
+      {
+        Coin* coin = &coins[i];
+        for(j = 0; j < coin->symbols.size; j++) lengths[coin->symbols.data[j]]++;
+      }
+    }
+
+    cleanup_coins(coins, coinmem);
+    myfree(coins);
+    cleanup_coins(prev_row, coinmem);
+    myfree(prev_row);
+  }
+
+  return error;
+}
+
+/*Create the Huffman tree given the symbol frequencies*/
+static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies,
+                                                size_t mincodes, size_t numcodes, unsigned maxbitlen)
+{
+  unsigned error = 0;
+  while(!frequencies[numcodes - 1] && numcodes > mincodes) numcodes--; /*trim zeroes*/
+  tree->maxbitlen = maxbitlen;
+  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
+  tree->lengths = (unsigned*)myrealloc(tree->lengths, numcodes * sizeof(unsigned));
+  if(!tree->lengths) return 83; /*alloc fail*/
+  /*initialize all lengths to 0*/
+  memset(tree->lengths, 0, numcodes * sizeof(unsigned));
+
+  error = lodepng_huffman_code_lengths(tree->lengths, frequencies, numcodes, maxbitlen);
+  if(!error) error = HuffmanTree_makeFromLengths2(tree);
+  return error;
+}
+
+static unsigned HuffmanTree_getCode(const HuffmanTree* tree, unsigned index)
+{
+  return tree->tree1d[index];
+}
+
+static unsigned HuffmanTree_getLength(const HuffmanTree* tree, unsigned index)
+{
+  return tree->lengths[index];
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+/*get the literal and length code tree of a deflated block with fixed tree, as per the deflate specification*/
+static unsigned generateFixedLitLenTree(HuffmanTree* tree)
+{
+  unsigned i, error = 0;
+  unsigned* bitlen = (unsigned*)mymalloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
+  if(!bitlen) return 83; /*alloc fail*/
+
+  /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
+  for(i =   0; i <= 143; i++) bitlen[i] = 8;
+  for(i = 144; i <= 255; i++) bitlen[i] = 9;
+  for(i = 256; i <= 279; i++) bitlen[i] = 7;
+  for(i = 280; i <= 287; i++) bitlen[i] = 8;
+
+  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15);
+
+  myfree(bitlen);
+  return error;
+}
+
+/*get the distance code tree of a deflated block with fixed tree, as specified in the deflate specification*/
+static unsigned generateFixedDistanceTree(HuffmanTree* tree)
+{
+  unsigned i, error = 0;
+  unsigned* bitlen = (unsigned*)mymalloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned));
+  if(!bitlen) return 83; /*alloc fail*/
+
+  /*there are 32 distance codes, but 30-31 are unused*/
+  for(i = 0; i < NUM_DISTANCE_SYMBOLS; i++) bitlen[i] = 5;
+  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DISTANCE_SYMBOLS, 15);
+
+  myfree(bitlen);
+  return error;
+}
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+/*
+returns the code, or (unsigned)(-1) if error happened
+inbitlength is the length of the complete buffer, in bits (so its byte length times 8)
+*/
+static unsigned huffmanDecodeSymbol(const unsigned char* in, size_t* bp,
+                                    const HuffmanTree* codetree, size_t inbitlength)
+{
+  unsigned treepos = 0, ct;
+  for(;;)
+  {
+    if(*bp >= inbitlength) return (unsigned)(-1); /*error: end of input memory reached without endcode*/
+    /*
+    decode the symbol from the tree. The "readBitFromStream" code is inlined in
+    the expression below because this is the biggest bottleneck while decoding
+    */
+    ct = codetree->tree2d[(treepos << 1) + READBIT(*bp, in)];
+    (*bp)++;
+    if(ct < codetree->numcodes) return ct; /*the symbol is decoded, return it*/
+    else treepos = ct - codetree->numcodes; /*symbol not yet decoded, instead move tree position*/
+
+    if(treepos >= codetree->numcodes) return (unsigned)(-1); /*error: it appeared outside the codetree*/
+  }
+}
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Inflator (Decompressor)                                                / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*get the tree of a deflated block with fixed tree, as specified in the deflate specification*/
+static void getTreeInflateFixed(HuffmanTree* tree_ll, HuffmanTree* tree_d)
+{
+  /*TODO: check for out of memory errors*/
+  generateFixedLitLenTree(tree_ll);
+  generateFixedDistanceTree(tree_d);
+}
+
+/*get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree*/
+static unsigned getTreeInflateDynamic(HuffmanTree* tree_ll, HuffmanTree* tree_d,
+                                      const unsigned char* in, size_t* bp, size_t inlength)
+{
+  /*make sure that length values that aren't filled in will be 0, or a wrong tree will be generated*/
+  unsigned error = 0;
+  unsigned n, HLIT, HDIST, HCLEN, i;
+  size_t inbitlength = inlength * 8;
+
+  /*see comments in deflateDynamic for explanation of the context and these variables, it is analogous*/
+  unsigned* bitlen_ll = 0; /*lit,len code lengths*/
+  unsigned* bitlen_d = 0; /*dist code lengths*/
+  /*code length code lengths ("clcl"), the bit lengths of the huffman tree used to compress bitlen_ll and bitlen_d*/
+  unsigned* bitlen_cl = 0;
+  HuffmanTree tree_cl; /*the code tree for code length codes (the huffman tree for compressed huffman trees)*/
+
+  if((*bp) >> 3 >= inlength - 2) return 49; /*error: the bit pointer is or will go past the memory*/
+
+  /*number of literal/length codes + 257. Unlike the spec, the value 257 is added to it here already*/
+  HLIT =  readBitsFromStream(bp, in, 5) + 257;
+  /*number of distance codes. Unlike the spec, the value 1 is added to it here already*/
+  HDIST = readBitsFromStream(bp, in, 5) + 1;
+  /*number of code length codes. Unlike the spec, the value 4 is added to it here already*/
+  HCLEN = readBitsFromStream(bp, in, 4) + 4;
+
+  HuffmanTree_init(&tree_cl);
+
+  while(!error)
+  {
+    /*read the code length codes out of 3 * (amount of code length codes) bits*/
+
+    bitlen_cl = (unsigned*)mymalloc(NUM_CODE_LENGTH_CODES * sizeof(unsigned));
+    if(!bitlen_cl) ERROR_BREAK(83 /*alloc fail*/);
+
+    for(i = 0; i < NUM_CODE_LENGTH_CODES; i++)
+    {
+      if(i < HCLEN) bitlen_cl[CLCL_ORDER[i]] = readBitsFromStream(bp, in, 3);
+      else bitlen_cl[CLCL_ORDER[i]] = 0; /*if not, it must stay 0*/
+    }
+
+    error = HuffmanTree_makeFromLengths(&tree_cl, bitlen_cl, NUM_CODE_LENGTH_CODES, 7);
+    if(error) break;
+
+    /*now we can use this tree to read the lengths for the tree that this function will return*/
+    bitlen_ll = (unsigned*)mymalloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
+    bitlen_d = (unsigned*)mymalloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned));
+    if(!bitlen_ll || !bitlen_d) ERROR_BREAK(83 /*alloc fail*/);
+    for(i = 0; i < NUM_DEFLATE_CODE_SYMBOLS; i++) bitlen_ll[i] = 0;
+    for(i = 0; i < NUM_DISTANCE_SYMBOLS; i++) bitlen_d[i] = 0;
+
+    /*i is the current symbol we're reading in the part that contains the code lengths of lit/len and dist codes*/
+    i = 0;
+    while(i < HLIT + HDIST)
+    {
+      unsigned code = huffmanDecodeSymbol(in, bp, &tree_cl, inbitlength);
+      if(code <= 15) /*a length code*/
+      {
+        if(i < HLIT) bitlen_ll[i] = code;
+        else bitlen_d[i - HLIT] = code;
+        i++;
+      }
+      else if(code == 16) /*repeat previous*/
+      {
+        unsigned replength = 3; /*read in the 2 bits that indicate repeat length (3-6)*/
+        unsigned value; /*set value to the previous code*/
+
+        if(*bp >= inbitlength) ERROR_BREAK(50); /*error, bit pointer jumps past memory*/
+        if (i == 0) ERROR_BREAK(54); /*can't repeat previous if i is 0*/
+
+        replength += readBitsFromStream(bp, in, 2);
+
+        if(i < HLIT + 1) value = bitlen_ll[i - 1];
+        else value = bitlen_d[i - HLIT - 1];
+        /*repeat this value in the next lengths*/
+        for(n = 0; n < replength; n++)
+        {
+          if(i >= HLIT + HDIST) ERROR_BREAK(13); /*error: i is larger than the amount of codes*/
+          if(i < HLIT) bitlen_ll[i] = value;
+          else bitlen_d[i - HLIT] = value;
+          i++;
+        }
+      }
+      else if(code == 17) /*repeat "0" 3-10 times*/
+      {
+        unsigned replength = 3; /*read in the bits that indicate repeat length*/
+        if(*bp >= inbitlength) ERROR_BREAK(50); /*error, bit pointer jumps past memory*/
+
+        replength += readBitsFromStream(bp, in, 3);
+
+        /*repeat this value in the next lengths*/
+        for(n = 0; n < replength; n++)
+        {
+          if(i >= HLIT + HDIST) ERROR_BREAK(14); /*error: i is larger than the amount of codes*/
+
+          if(i < HLIT) bitlen_ll[i] = 0;
+          else bitlen_d[i - HLIT] = 0;
+          i++;
+        }
+      }
+      else if(code == 18) /*repeat "0" 11-138 times*/
+      {
+        unsigned replength = 11; /*read in the bits that indicate repeat length*/
+        if(*bp >= inbitlength) ERROR_BREAK(50); /*error, bit pointer jumps past memory*/
+
+        replength += readBitsFromStream(bp, in, 7);
+
+        /*repeat this value in the next lengths*/
+        for(n = 0; n < replength; n++)
+        {
+          if(i >= HLIT + HDIST) ERROR_BREAK(15); /*error: i is larger than the amount of codes*/
+
+          if(i < HLIT) bitlen_ll[i] = 0;
+          else bitlen_d[i - HLIT] = 0;
+          i++;
+        }
+      }
+      else /*if(code == (unsigned)(-1))*/ /*huffmanDecodeSymbol returns (unsigned)(-1) in case of error*/
+      {
+        if(code == (unsigned)(-1))
+        {
+          /*return error code 10 or 11 depending on the situation that happened in huffmanDecodeSymbol
+          (10=no endcode, 11=wrong jump outside of tree)*/
+          error = (*bp) > inbitlength ? 10 : 11;
+        }
+        else error = 16; /*unexisting code, this can never happen*/
+        break;
+      }
+    }
+    if(error) break;
+
+    if(bitlen_ll[256] == 0) ERROR_BREAK(64); /*the length of the end code 256 must be larger than 0*/
+
+    /*now we've finally got HLIT and HDIST, so generate the code trees, and the function is done*/
+    error = HuffmanTree_makeFromLengths(tree_ll, bitlen_ll, NUM_DEFLATE_CODE_SYMBOLS, 15);
+    if(error) break;
+    error = HuffmanTree_makeFromLengths(tree_d, bitlen_d, NUM_DISTANCE_SYMBOLS, 15);
+
+    break; /*end of error-while*/
+  }
+
+  myfree(bitlen_cl);
+  myfree(bitlen_ll);
+  myfree(bitlen_d);
+  HuffmanTree_cleanup(&tree_cl);
+
+  return error;
+}
+
+/*inflate a block with dynamic of fixed Huffman tree*/
+static unsigned inflateHuffmanBlock(ucvector* out, const unsigned char* in, size_t* bp,
+                                    size_t* pos, size_t inlength, unsigned btype)
+{
+  unsigned error = 0;
+  HuffmanTree tree_ll; /*the huffman tree for literal and length codes*/
+  HuffmanTree tree_d; /*the huffman tree for distance codes*/
+  size_t inbitlength = inlength * 8;
+
+  HuffmanTree_init(&tree_ll);
+  HuffmanTree_init(&tree_d);
+
+  if(btype == 1) getTreeInflateFixed(&tree_ll, &tree_d);
+  else if(btype == 2) error = getTreeInflateDynamic(&tree_ll, &tree_d, in, bp, inlength);
+
+  while(!error) /*decode all symbols until end reached, breaks at end code*/
+  {
+    /*code_ll is literal, length or end code*/
+    unsigned code_ll = huffmanDecodeSymbol(in, bp, &tree_ll, inbitlength);
+    if(code_ll <= 255) /*literal symbol*/
+    {
+      if((*pos) >= out->size)
+      {
+        /*reserve more room at once*/
+        if(!ucvector_resize(out, ((*pos) + 1) * 2)) ERROR_BREAK(83 /*alloc fail*/);
+      }
+      out->data[(*pos)] = (unsigned char)(code_ll);
+      (*pos)++;
+    }
+    else if(code_ll >= FIRST_LENGTH_CODE_INDEX && code_ll <= LAST_LENGTH_CODE_INDEX) /*length code*/
+    {
+      unsigned code_d, distance;
+      unsigned numextrabits_l, numextrabits_d; /*extra bits for length and distance*/
+      size_t start, forward, backward, length;
+
+      /*part 1: get length base*/
+      length = LENGTHBASE[code_ll - FIRST_LENGTH_CODE_INDEX];
+
+      /*part 2: get extra bits and add the value of that to length*/
+      numextrabits_l = LENGTHEXTRA[code_ll - FIRST_LENGTH_CODE_INDEX];
+      if(*bp >= inbitlength) ERROR_BREAK(51); /*error, bit pointer will jump past memory*/
+      length += readBitsFromStream(bp, in, numextrabits_l);
+
+      /*part 3: get distance code*/
+      code_d = huffmanDecodeSymbol(in, bp, &tree_d, inbitlength);
+      if(code_d > 29)
+      {
+        if(code_ll == (unsigned)(-1)) /*huffmanDecodeSymbol returns (unsigned)(-1) in case of error*/
+        {
+          /*return error code 10 or 11 depending on the situation that happened in huffmanDecodeSymbol
+          (10=no endcode, 11=wrong jump outside of tree)*/
+          error = (*bp) > inlength * 8 ? 10 : 11;
+        }
+        else error = 18; /*error: invalid distance code (30-31 are never used)*/
+        break;
+      }
+      distance = DISTANCEBASE[code_d];
+
+      /*part 4: get extra bits from distance*/
+      numextrabits_d = DISTANCEEXTRA[code_d];
+      if(*bp >= inbitlength) ERROR_BREAK(51); /*error, bit pointer will jump past memory*/
+
+      distance += readBitsFromStream(bp, in, numextrabits_d);
+
+      /*part 5: fill in all the out[n] values based on the length and dist*/
+      start = (*pos);
+      if(distance > start) ERROR_BREAK(52); /*too long backward distance*/
+      backward = start - distance;
+      if((*pos) + length >= out->size)
+      {
+        /*reserve more room at once*/
+        if(!ucvector_resize(out, ((*pos) + length) * 2)) ERROR_BREAK(83 /*alloc fail*/);
+      }
+
+      for(forward = 0; forward < length; forward++)
+      {
+        out->data[(*pos)] = out->data[backward];
+        (*pos)++;
+        backward++;
+        if(backward >= start) backward = start - distance;
+      }
+    }
+    else if(code_ll == 256)
+    {
+      break; /*end code, break the loop*/
+    }
+    else /*if(code == (unsigned)(-1))*/ /*huffmanDecodeSymbol returns (unsigned)(-1) in case of error*/
+    {
+      /*return error code 10 or 11 depending on the situation that happened in huffmanDecodeSymbol
+      (10=no endcode, 11=wrong jump outside of tree)*/
+      error = (*bp) > inlength * 8 ? 10 : 11;
+      break;
+    }
+  }
+
+  HuffmanTree_cleanup(&tree_ll);
+  HuffmanTree_cleanup(&tree_d);
+
+  return error;
+}
+
+static unsigned inflateNoCompression(ucvector* out, const unsigned char* in, size_t* bp, size_t* pos, size_t inlength)
+{
+  /*go to first boundary of byte*/
+  size_t p;
+  unsigned LEN, NLEN, n, error = 0;
+  while(((*bp) & 0x7) != 0) (*bp)++;
+  p = (*bp) / 8; /*byte position*/
+
+  /*read LEN (2 bytes) and NLEN (2 bytes)*/
+  if(p >= inlength - 4) return 52; /*error, bit pointer will jump past memory*/
+  LEN = in[p] + 256 * in[p + 1]; p += 2;
+  NLEN = in[p] + 256 * in[p + 1]; p += 2;
+
+  /*check if 16-bit NLEN is really the one's complement of LEN*/
+  if(LEN + NLEN != 65535) return 21; /*error: NLEN is not one's complement of LEN*/
+
+  if((*pos) + LEN >= out->size)
+  {
+    if(!ucvector_resize(out, (*pos) + LEN)) return 83; /*alloc fail*/
+  }
+
+  /*read the literal data: LEN bytes are now stored in the out buffer*/
+  if(p + LEN > inlength) return 23; /*error: reading outside of in buffer*/
+  for(n = 0; n < LEN; n++) out->data[(*pos)++] = in[p++];
+
+  (*bp) = p * 8;
+
+  return error;
+}
+
+static unsigned lodepng_inflatev(ucvector* out,
+                                 const unsigned char* in, size_t insize,
+                                 const LodePNGDecompressSettings* settings)
+{
+  /*bit pointer in the "in" data, current byte is bp >> 3, current bit is bp & 0x7 (from lsb to msb of the byte)*/
+  size_t bp = 0;
+  unsigned BFINAL = 0;
+  size_t pos = 0; /*byte position in the out buffer*/
+
+  unsigned error = 0;
+
+  (void)settings;
+
+  while(!BFINAL)
+  {
+    unsigned BTYPE;
+    if(bp + 2 >= insize * 8) return 52; /*error, bit pointer will jump past memory*/
+    BFINAL = readBitFromStream(&bp, in);
+    BTYPE = 1 * readBitFromStream(&bp, in);
+    BTYPE += 2 * readBitFromStream(&bp, in);
+
+    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
+    else if(BTYPE == 0) error = inflateNoCompression(out, in, &bp, &pos, insize); /*no compression*/
+    else error = inflateHuffmanBlock(out, in, &bp, &pos, insize, BTYPE); /*compression, BTYPE 01 or 10*/
+
+    if(error) return error;
+  }
+
+  /*Only now we know the true size of out, resize it to that*/
+  if(!ucvector_resize(out, pos)) error = 83; /*alloc fail*/
+
+  return error;
+}
+
+unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
+                         const unsigned char* in, size_t insize,
+                         const LodePNGDecompressSettings* settings)
+{
+  unsigned error;
+  ucvector v;
+  ucvector_init_buffer(&v, *out, *outsize);
+  error = lodepng_inflatev(&v, in, insize, settings);
+  *out = v.data;
+  *outsize = v.size;
+  return error;
+}
+
+static unsigned inflate(unsigned char** out, size_t* outsize,
+                        const unsigned char* in, size_t insize,
+                        const LodePNGDecompressSettings* settings)
+{
+  if(settings->custom_inflate)
+  {
+    return settings->custom_inflate(out, outsize, in, insize, settings);
+  }
+  else
+  {
+    return lodepng_inflate(out, outsize, in, insize, settings);
+  }
+}
+
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Deflator (Compressor)                                                  / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+static const size_t MAX_SUPPORTED_DEFLATE_LENGTH = 258;
+
+/*bitlen is the size in bits of the code*/
+static void addHuffmanSymbol(size_t* bp, ucvector* compressed, unsigned code, unsigned bitlen)
+{
+  addBitsToStreamReversed(bp, compressed, code, bitlen);
+}
+
+/*search the index in the array, that has the largest value smaller than or equal to the given value,
+given array must be sorted (if no value is smaller, it returns the size of the given array)*/
+static size_t searchCodeIndex(const unsigned* array, size_t array_size, size_t value)
+{
+  /*linear search implementation*/
+  /*for(size_t i = 1; i < array_size; i++) if(array[i] > value) return i - 1;
+  return array_size - 1;*/
+
+  /*binary search implementation (not that much faster) (precondition: array_size > 0)*/
+  size_t left  = 1;
+  size_t right = array_size - 1;
+  while(left <= right)
+  {
+    size_t mid = (left + right) / 2;
+    if(array[mid] <= value) left = mid + 1; /*the value to find is more to the right*/
+    else if(array[mid - 1] > value) right = mid - 1; /*the value to find is more to the left*/
+    else return mid - 1;
+  }
+  return array_size - 1;
+}
+
+static void addLengthDistance(uivector* values, size_t length, size_t distance)
+{
+  /*values in encoded vector are those used by deflate:
+  0-255: literal bytes
+  256: end
+  257-285: length/distance pair (length code, followed by extra length bits, distance code, extra distance bits)
+  286-287: invalid*/
+
+  unsigned length_code = (unsigned)searchCodeIndex(LENGTHBASE, 29, length);
+  unsigned extra_length = (unsigned)(length - LENGTHBASE[length_code]);
+  unsigned dist_code = (unsigned)searchCodeIndex(DISTANCEBASE, 30, distance);
+  unsigned extra_distance = (unsigned)(distance - DISTANCEBASE[dist_code]);
+
+  uivector_push_back(values, length_code + FIRST_LENGTH_CODE_INDEX);
+  uivector_push_back(values, extra_length);
+  uivector_push_back(values, dist_code);
+  uivector_push_back(values, extra_distance);
+}
+
+static const unsigned HASH_NUM_VALUES = 65536;
+static const unsigned HASH_NUM_CHARACTERS = 3;
+static const unsigned HASH_SHIFT = 2;
+/*
+The HASH_NUM_CHARACTERS value is used to make encoding faster by using longer
+sequences to generate a hash value from the stream bytes. Setting it to 3
+gives exactly the same compression as the brute force method, since deflate's
+run length encoding starts with lengths of 3. Setting it to higher values,
+like 6, can make the encoding faster (not always though!), but will cause the
+encoding to miss any length between 3 and this value, so that the compression
+may be worse (but this can vary too depending on the image, sometimes it is
+even a bit better instead).
+The HASH_NUM_VALUES is the amount of unique possible hash values that
+combinations of bytes can give, the higher it is the more memory is needed, but
+if it's too low the advantage of hashing is gone.
+*/
+
+typedef struct Hash
+{
+  int* head; /*hash value to head circular pos*/
+  int* val; /*circular pos to hash value*/
+  /*circular pos to prev circular pos*/
+  unsigned short* chain;
+  unsigned short* zeros;
+} Hash;
+
+static unsigned hash_init(Hash* hash, unsigned windowsize)
+{
+  unsigned i;
+  hash->head = (int*)mymalloc(sizeof(int) * HASH_NUM_VALUES);
+  hash->val = (int*)mymalloc(sizeof(int) * windowsize);
+  hash->chain = (unsigned short*)mymalloc(sizeof(unsigned short) * windowsize);
+  hash->zeros = (unsigned short*)mymalloc(sizeof(unsigned short) * windowsize);
+
+  if(!hash->head || !hash->val || !hash->chain || !hash->zeros) return 83; /*alloc fail*/
+
+  /*initialize hash table*/
+  for(i = 0; i < HASH_NUM_VALUES; i++) hash->head[i] = -1;
+  for(i = 0; i < windowsize; i++) hash->val[i] = -1;
+  for(i = 0; i < windowsize; i++) hash->chain[i] = i; /*same value as index indicates uninitialized*/
+
+  return 0;
+}
+
+static void hash_cleanup(Hash* hash)
+{
+  myfree(hash->head);
+  myfree(hash->val);
+  myfree(hash->chain);
+  myfree(hash->zeros);
+}
+
+static unsigned getHash(const unsigned char* data, size_t size, size_t pos)
+{
+  unsigned result = 0;
+  size_t amount, i;
+  if(pos >= size) return 0;
+  amount = HASH_NUM_CHARACTERS;
+  if(pos + amount >= size) amount = size - pos;
+  for(i = 0; i < amount; i++) result ^= (data[pos + i] << (i * HASH_SHIFT));
+  return result % HASH_NUM_VALUES;
+}
+
+static unsigned countZeros(const unsigned char* data, size_t size, size_t pos)
+{
+  const unsigned char* start = data + pos;
+  const unsigned char* end = start + MAX_SUPPORTED_DEFLATE_LENGTH;
+  if(end > data + size) end = data + size;
+  data = start;
+  while (data != end && *data == 0) data++;
+  /*subtracting two addresses returned as 32-bit number (max value is MAX_SUPPORTED_DEFLATE_LENGTH)*/
+  return (unsigned)(data - start);
+}
+
+static void updateHashChain(Hash* hash, size_t pos, int hashval, unsigned windowsize)
+{
+  unsigned wpos = pos % windowsize;
+  hash->val[wpos] = hashval;
+  if(hash->head[hashval] != -1) hash->chain[wpos] = hash->head[hashval];
+  hash->head[hashval] = wpos;
+}
+
+/*
+LZ77-encode the data. Return value is error code. The input are raw bytes, the output
+is in the form of unsigned integers with codes representing for example literal bytes, or
+length/distance pairs.
+It uses a hash table technique to let it encode faster. When doing LZ77 encoding, a
+sliding window (of windowsize) is used, and all past bytes in that window can be used as
+the "dictionary". A brute force search through all possible distances would be slow, and
+this hash technique is one out of several ways to speed this up.
+*/
+static unsigned encodeLZ77(uivector* out, Hash* hash,
+                           const unsigned char* in, size_t inpos, size_t insize, unsigned windowsize,
+                           unsigned minmatch, unsigned nicematch, unsigned lazymatching)
+{
+  unsigned short numzeros = 0;
+  int usezeros = windowsize >= 8192; /*for small window size, the 'max chain length' optimization does a better job*/
+  unsigned pos, i, error = 0;
+  /*for large window lengths, assume the user wants no compression loss. Otherwise, max hash chain length speedup.*/
+  unsigned maxchainlength = windowsize >= 8192 ? windowsize : windowsize / 8;
+  unsigned maxlazymatch = windowsize >= 8192 ? MAX_SUPPORTED_DEFLATE_LENGTH : 64;
+
+  if(!error)
+  {
+    unsigned offset; /*the offset represents the distance in LZ77 terminology*/
+    unsigned length;
+    unsigned lazy = 0;
+    unsigned lazylength = 0, lazyoffset = 0;
+    unsigned hashval;
+    unsigned current_offset, current_length;
+    const unsigned char *lastptr, *foreptr, *backptr;
+    unsigned short hashpos, prevpos;
+
+    for(pos = inpos; pos < insize; pos++)
+    {
+      size_t wpos = pos % windowsize; /*position for in 'circular' hash buffers*/
+
+      hashval = getHash(in, insize, pos);
+      updateHashChain(hash, pos, hashval, windowsize);
+
+      if(usezeros && hashval == 0)
+      {
+        numzeros = countZeros(in, insize, pos);
+        hash->zeros[wpos] = numzeros;
+      }
+
+      /*the length and offset found for the current position*/
+      length = 0;
+      offset = 0;
+
+      prevpos = hash->head[hashval];
+      hashpos = hash->chain[prevpos];
+
+      lastptr = &in[insize < pos + MAX_SUPPORTED_DEFLATE_LENGTH ? insize : pos + MAX_SUPPORTED_DEFLATE_LENGTH];
+
+      /*search for the longest string*/
+      if(hash->val[wpos] == (int)hashval)
+      {
+        unsigned chainlength = 0;
+        for(;;)
+        {
+          /*stop when went completely around the circular buffer*/
+          if(prevpos < wpos && hashpos > prevpos && hashpos <= wpos) break;
+          if(prevpos > wpos && (hashpos <= wpos || hashpos > prevpos)) break;
+          if(chainlength++ >= maxchainlength) break;
+
+          current_offset = hashpos <= wpos ? wpos - hashpos : wpos - hashpos + windowsize;
+          if(current_offset > 0)
+          {
+            /*test the next characters*/
+            foreptr = &in[pos];
+            backptr = &in[pos - current_offset];
+
+            /*common case in PNGs is lots of zeros. Quickly skip over them as a speedup*/
+            if(usezeros && hashval == 0 && hash->val[hashpos] == 0 /*hashval[hashpos] may be out of date*/)
+            {
+              unsigned short skip = hash->zeros[hashpos];
+              if(skip > numzeros) skip = numzeros;
+              backptr += skip;
+              foreptr += skip;
+            }
+
+            /* multiple checks at once per array bounds check */
+            while(foreptr != lastptr && *backptr == *foreptr) /*maximum supported length by deflate is max length*/
+            {
+              ++backptr;
+              ++foreptr;
+            }
+            current_length = (unsigned)(foreptr - &in[pos]);
+
+            if(current_length > length)
+            {
+              length = current_length; /*the longest length*/
+              offset = current_offset; /*the offset that is related to this longest length*/
+              /*jump out once a length of max length is found (speed gain)*/
+              if(current_length >= nicematch || current_length == MAX_SUPPORTED_DEFLATE_LENGTH) break;
+            }
+          }
+
+          if(hashpos == hash->chain[hashpos]) break;
+
+          prevpos = hashpos;
+          hashpos = hash->chain[hashpos];
+        }
+      }
+
+      if(lazymatching)
+      {
+        if(!lazy && length >= 3 && length <= maxlazymatch && length < MAX_SUPPORTED_DEFLATE_LENGTH)
+        {
+          lazy = 1;
+          lazylength = length;
+          lazyoffset = offset;
+          continue; /*try the next byte*/
+        }
+        if(lazy)
+        {
+          lazy = 0;
+          if(pos == 0) ERROR_BREAK(81);
+          if(length > lazylength + 1)
+          {
+            /*push the previous character as literal*/
+            if(!uivector_push_back(out, in[pos - 1])) ERROR_BREAK(83 /*alloc fail*/);
+          }
+          else
+          {
+            length = lazylength;
+            offset = lazyoffset;
+            hash->head[hashval] = -1; /*the same hashchain update will be done, this ensures no wrong alteration*/
+            pos--;
+          }
+        }
+      }
+      if(length >= 3 && offset > windowsize) ERROR_BREAK(86 /*too big (or overflown negative) offset*/);
+
+      /**encode it as length/distance pair or literal value**/
+      if(length < 3) /*only lengths of 3 or higher are supported as length/distance pair*/
+      {
+        if(!uivector_push_back(out, in[pos])) ERROR_BREAK(83 /*alloc fail*/);
+      }
+      else if(length < minmatch || (length == 3 && offset > 4096))
+      {
+        /*compensate for the fact that longer offsets have more extra bits, a
+        length of only 3 may be not worth it then*/
+        if(!uivector_push_back(out, in[pos])) ERROR_BREAK(83 /*alloc fail*/);
+      }
+      else
+      {
+        addLengthDistance(out, length, offset);
+        for(i = 1; i < length; i++)
+        {
+          pos++;
+          hashval = getHash(in, insize, pos);
+          updateHashChain(hash, pos, hashval, windowsize);
+          if(usezeros && hashval == 0)
+          {
+            hash->zeros[pos % windowsize] = countZeros(in, insize, pos);
+          }
+        }
+      }
+
+    } /*end of the loop through each character of input*/
+  } /*end of "if(!error)"*/
+
+  return error;
+}
+
+/* /////////////////////////////////////////////////////////////////////////// */
+
+static unsigned deflateNoCompression(ucvector* out, const unsigned char* data, size_t datasize)
+{
+  /*non compressed deflate block data: 1 bit BFINAL,2 bits BTYPE,(5 bits): it jumps to start of next byte,
+  2 bytes LEN, 2 bytes NLEN, LEN bytes literal DATA*/
+
+  size_t i, j, numdeflateblocks = (datasize + 65534) / 65535;
+  unsigned datapos = 0;
+  for(i = 0; i < numdeflateblocks; i++)
+  {
+    unsigned BFINAL, BTYPE, LEN, NLEN;
+    unsigned char firstbyte;
+
+    BFINAL = (i == numdeflateblocks - 1);
+    BTYPE = 0;
+
+    firstbyte = (unsigned char)(BFINAL + ((BTYPE & 1) << 1) + ((BTYPE & 2) << 1));
+    ucvector_push_back(out, firstbyte);
+
+    LEN = 65535;
+    if(datasize - datapos < 65535) LEN = (unsigned)datasize - datapos;
+    NLEN = 65535 - LEN;
+
+    ucvector_push_back(out, (unsigned char)(LEN % 256));
+    ucvector_push_back(out, (unsigned char)(LEN / 256));
+    ucvector_push_back(out, (unsigned char)(NLEN % 256));
+    ucvector_push_back(out, (unsigned char)(NLEN / 256));
+
+    /*Decompressed data*/
+    for(j = 0; j < 65535 && datapos < datasize; j++)
+    {
+      ucvector_push_back(out, data[datapos++]);
+    }
+  }
+
+  return 0;
+}
+
+/*
+write the lz77-encoded data, which has lit, len and dist codes, to compressed stream using huffman trees.
+tree_ll: the tree for lit and len codes.
+tree_d: the tree for distance codes.
+*/
+static void writeLZ77data(size_t* bp, ucvector* out, const uivector* lz77_encoded,
+                          const HuffmanTree* tree_ll, const HuffmanTree* tree_d)
+{
+  size_t i = 0;
+  for(i = 0; i < lz77_encoded->size; i++)
+  {
+    unsigned val = lz77_encoded->data[i];
+    addHuffmanSymbol(bp, out, HuffmanTree_getCode(tree_ll, val), HuffmanTree_getLength(tree_ll, val));
+    if(val > 256) /*for a length code, 3 more things have to be added*/
+    {
+      unsigned length_index = val - FIRST_LENGTH_CODE_INDEX;
+      unsigned n_length_extra_bits = LENGTHEXTRA[length_index];
+      unsigned length_extra_bits = lz77_encoded->data[++i];
+
+      unsigned distance_code = lz77_encoded->data[++i];
+
+      unsigned distance_index = distance_code;
+      unsigned n_distance_extra_bits = DISTANCEEXTRA[distance_index];
+      unsigned distance_extra_bits = lz77_encoded->data[++i];
+
+      addBitsToStream(bp, out, length_extra_bits, n_length_extra_bits);
+      addHuffmanSymbol(bp, out, HuffmanTree_getCode(tree_d, distance_code),
+                       HuffmanTree_getLength(tree_d, distance_code));
+      addBitsToStream(bp, out, distance_extra_bits, n_distance_extra_bits);
+    }
+  }
+}
+
+/*Deflate for a block of type "dynamic", that is, with freely, optimally, created huffman trees*/
+static unsigned deflateDynamic(ucvector* out, size_t* bp, Hash* hash,
+                               const unsigned char* data, size_t datapos, size_t dataend,
+                               const LodePNGCompressSettings* settings, int final)
+{
+  unsigned error = 0;
+
+  /*
+  A block is compressed as follows: The PNG data is lz77 encoded, resulting in
+  literal bytes and length/distance pairs. This is then huffman compressed with
+  two huffman trees. One huffman tree is used for the lit and len values ("ll"),
+  another huffman tree is used for the dist values ("d"). These two trees are
+  stored using their code lengths, and to compress even more these code lengths
+  are also run-length encoded and huffman compressed. This gives a huffman tree
+  of code lengths "cl". The code lenghts used to describe this third tree are
+  the code length code lengths ("clcl").
+  */
+
+  /*The lz77 encoded data, represented with integers since there will also be length and distance codes in it*/
+  uivector lz77_encoded;
+  HuffmanTree tree_ll; /*tree for lit,len values*/
+  HuffmanTree tree_d; /*tree for distance codes*/
+  HuffmanTree tree_cl; /*tree for encoding the code lengths representing tree_ll and tree_d*/
+  uivector frequencies_ll; /*frequency of lit,len codes*/
+  uivector frequencies_d; /*frequency of dist codes*/
+  uivector frequencies_cl; /*frequency of code length codes*/
+  uivector bitlen_lld; /*lit,len,dist code lenghts (int bits), literally (without repeat codes).*/
+  uivector bitlen_lld_e; /*bitlen_lld encoded with repeat codes (this is a rudemtary run length compression)*/
+  /*bitlen_cl is the code length code lengths ("clcl"). The bit lengths of codes to represent tree_cl
+  (these are written as is in the file, it would be crazy to compress these using yet another huffman
+  tree that needs to be represented by yet another set of code lengths)*/
+  uivector bitlen_cl;
+  size_t datasize = dataend - datapos;
+
+  /*
+  Due to the huffman compression of huffman tree representations ("two levels"), there are some anologies:
+  bitlen_lld is to tree_cl what data is to tree_ll and tree_d.
+  bitlen_lld_e is to bitlen_lld what lz77_encoded is to data.
+  bitlen_cl is to bitlen_lld_e what bitlen_lld is to lz77_encoded.
+  */
+
+  unsigned BFINAL = final;
+  size_t numcodes_ll, numcodes_d, i;
+  unsigned HLIT, HDIST, HCLEN;
+
+  uivector_init(&lz77_encoded);
+  HuffmanTree_init(&tree_ll);
+  HuffmanTree_init(&tree_d);
+  HuffmanTree_init(&tree_cl);
+  uivector_init(&frequencies_ll);
+  uivector_init(&frequencies_d);
+  uivector_init(&frequencies_cl);
+  uivector_init(&bitlen_lld);
+  uivector_init(&bitlen_lld_e);
+  uivector_init(&bitlen_cl);
+
+  /*This while loop never loops due to a break at the end, it is here to
+  allow breaking out of it to the cleanup phase on error conditions.*/
+  while(!error)
+  {
+    if(settings->use_lz77)
+    {
+      error = encodeLZ77(&lz77_encoded, hash, data, datapos, dataend, settings->windowsize,
+                         settings->minmatch, settings->nicematch, settings->lazymatching);
+      if(error) break;
+    }
+    else
+    {
+      if(!uivector_resize(&lz77_encoded, datasize)) ERROR_BREAK(83 /*alloc fail*/);
+      for(i = datapos; i < dataend; i++) lz77_encoded.data[i] = data[i]; /*no LZ77, but still will be Huffman compressed*/
+    }
+
+    if(!uivector_resizev(&frequencies_ll, 286, 0)) ERROR_BREAK(83 /*alloc fail*/);
+    if(!uivector_resizev(&frequencies_d, 30, 0)) ERROR_BREAK(83 /*alloc fail*/);
+
+    /*Count the frequencies of lit, len and dist codes*/
+    for(i = 0; i < lz77_encoded.size; i++)
+    {
+      unsigned symbol = lz77_encoded.data[i];
+      frequencies_ll.data[symbol]++;
+      if(symbol > 256)
+      {
+        unsigned dist = lz77_encoded.data[i + 2];
+        frequencies_d.data[dist]++;
+        i += 3;
+      }
+    }
+    frequencies_ll.data[256] = 1; /*there will be exactly 1 end code, at the end of the block*/
+
+    /*Make both huffman trees, one for the lit and len codes, one for the dist codes*/
+    error = HuffmanTree_makeFromFrequencies(&tree_ll, frequencies_ll.data, 257, frequencies_ll.size, 15);
+    if(error) break;
+    /*2, not 1, is chosen for mincodes: some buggy PNG decoders require at least 2 symbols in the dist tree*/
+    error = HuffmanTree_makeFromFrequencies(&tree_d, frequencies_d.data, 2, frequencies_d.size, 15);
+    if(error) break;
+
+    numcodes_ll = tree_ll.numcodes; if(numcodes_ll > 286) numcodes_ll = 286;
+    numcodes_d = tree_d.numcodes; if(numcodes_d > 30) numcodes_d = 30;
+    /*store the code lengths of both generated trees in bitlen_lld*/
+    for(i = 0; i < numcodes_ll; i++) uivector_push_back(&bitlen_lld, HuffmanTree_getLength(&tree_ll, (unsigned)i));
+    for(i = 0; i < numcodes_d; i++) uivector_push_back(&bitlen_lld, HuffmanTree_getLength(&tree_d, (unsigned)i));
+
+    /*run-length compress bitlen_ldd into bitlen_lld_e by using repeat codes 16 (copy length 3-6 times),
+    17 (3-10 zeroes), 18 (11-138 zeroes)*/
+    for(i = 0; i < (unsigned)bitlen_lld.size; i++)
+    {
+      unsigned j = 0; /*amount of repititions*/
+      while(i + j + 1 < (unsigned)bitlen_lld.size && bitlen_lld.data[i + j + 1] == bitlen_lld.data[i]) j++;
+
+      if(bitlen_lld.data[i] == 0 && j >= 2) /*repeat code for zeroes*/
+      {
+        j++; /*include the first zero*/
+        if(j <= 10) /*repeat code 17 supports max 10 zeroes*/
+        {
+          uivector_push_back(&bitlen_lld_e, 17);
+          uivector_push_back(&bitlen_lld_e, j - 3);
+        }
+        else /*repeat code 18 supports max 138 zeroes*/
+        {
+          if(j > 138) j = 138;
+          uivector_push_back(&bitlen_lld_e, 18);
+          uivector_push_back(&bitlen_lld_e, j - 11);
+        }
+        i += (j - 1);
+      }
+      else if(j >= 3) /*repeat code for value other than zero*/
+      {
+        size_t k;
+        unsigned num = j / 6, rest = j % 6;
+        uivector_push_back(&bitlen_lld_e, bitlen_lld.data[i]);
+        for(k = 0; k < num; k++)
+        {
+          uivector_push_back(&bitlen_lld_e, 16);
+          uivector_push_back(&bitlen_lld_e, 6 - 3);
+        }
+        if(rest >= 3)
+        {
+          uivector_push_back(&bitlen_lld_e, 16);
+          uivector_push_back(&bitlen_lld_e, rest - 3);
+        }
+        else j -= rest;
+        i += j;
+      }
+      else /*too short to benefit from repeat code*/
+      {
+        uivector_push_back(&bitlen_lld_e, bitlen_lld.data[i]);
+      }
+    }
+
+    /*generate tree_cl, the huffmantree of huffmantrees*/
+
+    if(!uivector_resizev(&frequencies_cl, NUM_CODE_LENGTH_CODES, 0)) ERROR_BREAK(83 /*alloc fail*/);
+    for(i = 0; i < bitlen_lld_e.size; i++)
+    {
+      frequencies_cl.data[bitlen_lld_e.data[i]]++;
+      /*after a repeat code come the bits that specify the number of repetitions,
+      those don't need to be in the frequencies_cl calculation*/
+      if(bitlen_lld_e.data[i] >= 16) i++;
+    }
+
+    error = HuffmanTree_makeFromFrequencies(&tree_cl, frequencies_cl.data,
+                                            frequencies_cl.size, frequencies_cl.size, 7);
+    if(error) break;
+
+    if(!uivector_resize(&bitlen_cl, tree_cl.numcodes)) ERROR_BREAK(83 /*alloc fail*/);
+    for(i = 0; i < tree_cl.numcodes; i++)
+    {
+      /*lenghts of code length tree is in the order as specified by deflate*/
+      bitlen_cl.data[i] = HuffmanTree_getLength(&tree_cl, CLCL_ORDER[i]);
+    }
+    while(bitlen_cl.data[bitlen_cl.size - 1] == 0 && bitlen_cl.size > 4)
+    {
+      /*remove zeros at the end, but minimum size must be 4*/
+      if(!uivector_resize(&bitlen_cl, bitlen_cl.size - 1)) ERROR_BREAK(83 /*alloc fail*/);
+    }
+    if(error) break;
+
+    /*
+    Write everything into the output
+
+    After the BFINAL and BTYPE, the dynamic block consists out of the following:
+    - 5 bits HLIT, 5 bits HDIST, 4 bits HCLEN
+    - (HCLEN+4)*3 bits code lengths of code length alphabet
+    - HLIT + 257 code lenghts of lit/length alphabet (encoded using the code length
+      alphabet, + possible repetition codes 16, 17, 18)
+    - HDIST + 1 code lengths of distance alphabet (encoded using the code length
+      alphabet, + possible repetition codes 16, 17, 18)
+    - compressed data
+    - 256 (end code)
+    */
+
+    /*Write block type*/
+    addBitToStream(bp, out, BFINAL);
+    addBitToStream(bp, out, 0); /*first bit of BTYPE "dynamic"*/
+    addBitToStream(bp, out, 1); /*second bit of BTYPE "dynamic"*/
+
+    /*write the HLIT, HDIST and HCLEN values*/
+    HLIT = (unsigned)(numcodes_ll - 257);
+    HDIST = (unsigned)(numcodes_d - 1);
+    HCLEN = (unsigned)bitlen_cl.size - 4;
+    /*trim zeroes for HCLEN. HLIT and HDIST were already trimmed at tree creation*/
+    while(!bitlen_cl.data[HCLEN + 4 - 1] && HCLEN > 0) HCLEN--;
+    addBitsToStream(bp, out, HLIT, 5);
+    addBitsToStream(bp, out, HDIST, 5);
+    addBitsToStream(bp, out, HCLEN, 4);
+
+    /*write the code lenghts of the code length alphabet*/
+    for(i = 0; i < HCLEN + 4; i++) addBitsToStream(bp, out, bitlen_cl.data[i], 3);
+
+    /*write the lenghts of the lit/len AND the dist alphabet*/
+    for(i = 0; i < bitlen_lld_e.size; i++)
+    {
+      addHuffmanSymbol(bp, out, HuffmanTree_getCode(&tree_cl, bitlen_lld_e.data[i]),
+                       HuffmanTree_getLength(&tree_cl, bitlen_lld_e.data[i]));
+      /*extra bits of repeat codes*/
+      if(bitlen_lld_e.data[i] == 16) addBitsToStream(bp, out, bitlen_lld_e.data[++i], 2);
+      else if(bitlen_lld_e.data[i] == 17) addBitsToStream(bp, out, bitlen_lld_e.data[++i], 3);
+      else if(bitlen_lld_e.data[i] == 18) addBitsToStream(bp, out, bitlen_lld_e.data[++i], 7);
+    }
+
+    /*write the compressed data symbols*/
+    writeLZ77data(bp, out, &lz77_encoded, &tree_ll, &tree_d);
+    /*error: the length of the end code 256 must be larger than 0*/
+    if(HuffmanTree_getLength(&tree_ll, 256) == 0) ERROR_BREAK(64);
+
+    /*write the end code*/
+    addHuffmanSymbol(bp, out, HuffmanTree_getCode(&tree_ll, 256), HuffmanTree_getLength(&tree_ll, 256));
+
+    break; /*end of error-while*/
+  }
+
+  /*cleanup*/
+  uivector_cleanup(&lz77_encoded);
+  HuffmanTree_cleanup(&tree_ll);
+  HuffmanTree_cleanup(&tree_d);
+  HuffmanTree_cleanup(&tree_cl);
+  uivector_cleanup(&frequencies_ll);
+  uivector_cleanup(&frequencies_d);
+  uivector_cleanup(&frequencies_cl);
+  uivector_cleanup(&bitlen_lld_e);
+  uivector_cleanup(&bitlen_lld);
+  uivector_cleanup(&bitlen_cl);
+
+  return error;
+}
+
+static unsigned deflateFixed(ucvector* out, size_t* bp, Hash* hash,
+                             const unsigned char* data,
+                             size_t datapos, size_t dataend,
+                             const LodePNGCompressSettings* settings, int final)
+{
+  HuffmanTree tree_ll; /*tree for literal values and length codes*/
+  HuffmanTree tree_d; /*tree for distance codes*/
+
+  unsigned BFINAL = final;
+  unsigned error = 0;
+  size_t i;
+
+  HuffmanTree_init(&tree_ll);
+  HuffmanTree_init(&tree_d);
+
+  generateFixedLitLenTree(&tree_ll);
+  generateFixedDistanceTree(&tree_d);
+
+  addBitToStream(bp, out, BFINAL);
+  addBitToStream(bp, out, 1); /*first bit of BTYPE*/
+  addBitToStream(bp, out, 0); /*second bit of BTYPE*/
+
+  if(settings->use_lz77) /*LZ77 encoded*/
+  {
+    uivector lz77_encoded;
+    uivector_init(&lz77_encoded);
+    error = encodeLZ77(&lz77_encoded, hash, data, datapos, dataend, settings->windowsize,
+                       settings->minmatch, settings->nicematch, settings->lazymatching);
+    if(!error) writeLZ77data(bp, out, &lz77_encoded, &tree_ll, &tree_d);
+    uivector_cleanup(&lz77_encoded);
+  }
+  else /*no LZ77, but still will be Huffman compressed*/
+  {
+    for(i = datapos; i < dataend; i++)
+    {
+      addHuffmanSymbol(bp, out, HuffmanTree_getCode(&tree_ll, data[i]), HuffmanTree_getLength(&tree_ll, data[i]));
+    }
+  }
+  /*add END code*/
+  if(!error) addHuffmanSymbol(bp, out, HuffmanTree_getCode(&tree_ll, 256), HuffmanTree_getLength(&tree_ll, 256));
+
+  /*cleanup*/
+  HuffmanTree_cleanup(&tree_ll);
+  HuffmanTree_cleanup(&tree_d);
+
+  return error;
+}
+
+static unsigned lodepng_deflatev(ucvector* out, const unsigned char* in, size_t insize,
+                                 const LodePNGCompressSettings* settings)
+{
+  unsigned error = 0;
+  size_t i, blocksize, numdeflateblocks;
+  size_t bp = 0; /*the bit pointer*/
+  Hash hash;
+
+  if(settings->btype > 2) return 61;
+  else if(settings->btype == 0) return deflateNoCompression(out, in, insize);
+  else if(settings->btype == 1) blocksize = insize;
+  else /*if(settings->btype == 2)*/
+  {
+    blocksize = insize / 8 + 8;
+    if(blocksize < 65535) blocksize = 65535;
+  }
+
+  numdeflateblocks = (insize + blocksize - 1) / blocksize;
+  if(numdeflateblocks == 0) numdeflateblocks = 1;
+
+  error = hash_init(&hash, settings->windowsize);
+  if(error) return error;
+
+  for(i = 0; i < numdeflateblocks && !error; i++)
+  {
+    int final = i == numdeflateblocks - 1;
+    size_t start = i * blocksize;
+    size_t end = start + blocksize;
+    if(end > insize) end = insize;
+
+    if(settings->btype == 1) error = deflateFixed(out, &bp, &hash, in, start, end, settings, final);
+    else if(settings->btype == 2) error = deflateDynamic(out, &bp, &hash, in, start, end, settings, final);
+  }
+
+  hash_cleanup(&hash);
+
+  return error;
+}
+
+unsigned lodepng_deflate(unsigned char** out, size_t* outsize,
+                         const unsigned char* in, size_t insize,
+                         const LodePNGCompressSettings* settings)
+{
+  unsigned error;
+  ucvector v;
+  ucvector_init_buffer(&v, *out, *outsize);
+  error = lodepng_deflatev(&v, in, insize, settings);
+  *out = v.data;
+  *outsize = v.size;
+  return error;
+}
+
+static unsigned deflate(unsigned char** out, size_t* outsize,
+                        const unsigned char* in, size_t insize,
+                        const LodePNGCompressSettings* settings)
+{
+  if(settings->custom_deflate)
+  {
+    return settings->custom_deflate(out, outsize, in, insize, settings);
+  }
+  else
+  {
+    return lodepng_deflate(out, outsize, in, insize, settings);
+  }
+}
+
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Adler32                                                                  */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len)
+{
+   unsigned s1 = adler & 0xffff;
+   unsigned s2 = (adler >> 16) & 0xffff;
+
+  while(len > 0)
+  {
+    /*at least 5550 sums can be done before the sums overflow, saving a lot of module divisions*/
+    unsigned amount = len > 5550 ? 5550 : len;
+    len -= amount;
+    while(amount > 0)
+    {
+      s1 += (*data++);
+      s2 += s1;
+      amount--;
+    }
+    s1 %= 65521;
+    s2 %= 65521;
+  }
+
+  return (s2 << 16) | s1;
+}
+
+/*Return the adler32 of the bytes data[0..len-1]*/
+static unsigned adler32(const unsigned char* data, unsigned len)
+{
+  return update_adler32(1L, data, len);
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Zlib                                                                   / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                                 size_t insize, const LodePNGDecompressSettings* settings)
+{
+  unsigned error = 0;
+  unsigned CM, CINFO, FDICT;
+
+  if(insize < 2) return 53; /*error, size of zlib data too small*/
+  /*read information from zlib header*/
+  if((in[0] * 256 + in[1]) % 31 != 0)
+  {
+    /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/
+    return 24;
+  }
+
+  CM = in[0] & 15;
+  CINFO = (in[0] >> 4) & 15;
+  /*FCHECK = in[1] & 31;*/ /*FCHECK is already tested above*/
+  FDICT = (in[1] >> 5) & 1;
+  /*FLEVEL = (in[1] >> 6) & 3;*/ /*FLEVEL is not used here*/
+
+  if(CM != 8 || CINFO > 7)
+  {
+    /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/
+    return 25;
+  }
+  if(FDICT != 0)
+  {
+    /*error: the specification of PNG says about the zlib stream:
+      "The additional flags shall not specify a preset dictionary."*/
+    return 26;
+  }
+
+  error = inflate(out, outsize, in + 2, insize - 2, settings);
+  if(error) return error;
+
+  if(!settings->ignore_adler32)
+  {
+    unsigned ADLER32 = lodepng_read32bitInt(&in[insize - 4]);
+    unsigned checksum = adler32(*out, (unsigned)(*outsize));
+    if(checksum != ADLER32) return 58; /*error, adler checksum not correct, data must be corrupted*/
+  }
+
+  return 0; /*no error*/
+}
+
+static unsigned zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                                size_t insize, const LodePNGDecompressSettings* settings)
+{
+  if(settings->custom_zlib)
+    return settings->custom_zlib(out, outsize, in, insize, settings);
+  else
+    return lodepng_zlib_decompress(out, outsize, in, insize, settings);
+}
+
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                               size_t insize, const LodePNGCompressSettings* settings)
+{
+  /*initially, *out must be NULL and outsize 0, if you just give some random *out
+  that's pointing to a non allocated buffer, this'll crash*/
+  ucvector outv;
+  size_t i;
+  unsigned error;
+  unsigned char* deflatedata = 0;
+  size_t deflatesize = 0;
+
+  unsigned ADLER32;
+  /*zlib data: 1 byte CMF (CM+CINFO), 1 byte FLG, deflate data, 4 byte ADLER32 checksum of the Decompressed data*/
+  unsigned CMF = 120; /*0b01111000: CM 8, CINFO 7. With CINFO 7, any window size up to 32768 can be used.*/
+  unsigned FLEVEL = 0;
+  unsigned FDICT = 0;
+  unsigned CMFFLG = 256 * CMF + FDICT * 32 + FLEVEL * 64;
+  unsigned FCHECK = 31 - CMFFLG % 31;
+  CMFFLG += FCHECK;
+
+  /*ucvector-controlled version of the output buffer, for dynamic array*/
+  ucvector_init_buffer(&outv, *out, *outsize);
+
+  ucvector_push_back(&outv, (unsigned char)(CMFFLG / 256));
+  ucvector_push_back(&outv, (unsigned char)(CMFFLG % 256));
+
+  error = deflate(&deflatedata, &deflatesize, in, insize, settings);
+
+  if(!error)
+  {
+    ADLER32 = adler32(in, (unsigned)insize);
+    for(i = 0; i < deflatesize; i++) ucvector_push_back(&outv, deflatedata[i]);
+    free(deflatedata);
+    lodepng_add32bitInt(&outv, ADLER32);
+  }
+
+  *out = outv.data;
+  *outsize = outv.size;
+
+  return error;
+}
+
+/* compress using the default or custom zlib function */
+static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                              size_t insize, const LodePNGCompressSettings* settings)
+{
+  if(settings->custom_zlib)
+  {
+    return settings->custom_zlib(out, outsize, in, insize, settings);
+  }
+  else
+  {
+    return lodepng_zlib_compress(out, outsize, in, insize, settings);
+  }
+}
+
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#else /*no LODEPNG_COMPILE_ZLIB*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+static unsigned zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                                size_t insize, const LodePNGDecompressSettings* settings)
+{
+  if (!settings->custom_zlib) return 87; /*no custom zlib function provided */
+  return settings->custom_zlib(out, outsize, in, insize, settings);
+}
+#endif /*LODEPNG_COMPILE_DECODER*/
+#ifdef LODEPNG_COMPILE_ENCODER
+static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
+                              size_t insize, const LodePNGCompressSettings* settings)
+{
+  if (!settings->custom_zlib) return 87; /*no custom zlib function provided */
+  return settings->custom_zlib(out, outsize, in, insize, settings);
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#endif /*LODEPNG_COMPILE_ZLIB*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+/*this is a good tradeoff between speed and compression ratio*/
+#define DEFAULT_WINDOWSIZE 2048
+
+void lodepng_compress_settings_init(LodePNGCompressSettings* settings)
+{
+  /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
+  settings->btype = 2;
+  settings->use_lz77 = 1;
+  settings->windowsize = DEFAULT_WINDOWSIZE;
+  settings->minmatch = 3;
+  settings->nicematch = 128;
+  settings->lazymatching = 1;
+
+  settings->custom_zlib = 0;
+  settings->custom_deflate = 0;
+  settings->custom_context = 0;
+}
+
+const LodePNGCompressSettings lodepng_default_compress_settings = {2, 1, DEFAULT_WINDOWSIZE, 3, 128, 1, 0, 0, 0};
+
+
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings)
+{
+  settings->ignore_adler32 = 0;
+
+  settings->custom_zlib = 0;
+  settings->custom_inflate = 0;
+  settings->custom_context = 0;
+}
+
+const LodePNGDecompressSettings lodepng_default_decompress_settings = {0, 0, 0, 0};
+
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* // End of Zlib related code. Begin of PNG related code.                 // */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+#ifdef LODEPNG_COMPILE_PNG
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / CRC32                                                                  / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+static unsigned Crc32_crc_table_computed = 0;
+static unsigned Crc32_crc_table[256];
+
+/*Make the table for a fast CRC.*/
+static void Crc32_make_crc_table(void)
+{
+  unsigned c, k, n;
+  for(n = 0; n < 256; n++)
+  {
+    c = n;
+    for(k = 0; k < 8; k++)
+    {
+      if(c & 1) c = 0xedb88320L ^ (c >> 1);
+      else c = c >> 1;
+    }
+    Crc32_crc_table[n] = c;
+  }
+  Crc32_crc_table_computed = 1;
+}
+
+/*Update a running CRC with the bytes buf[0..len-1]--the CRC should be
+initialized to all 1's, and the transmitted value is the 1's complement of the
+final running CRC (see the crc() routine below).*/
+static unsigned Crc32_update_crc(const unsigned char* buf, unsigned crc, size_t len)
+{
+  unsigned c = crc;
+  size_t n;
+
+  if(!Crc32_crc_table_computed) Crc32_make_crc_table();
+  for(n = 0; n < len; n++)
+  {
+    c = Crc32_crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
+  }
+  return c;
+}
+
+/*Return the CRC of the bytes buf[0..len-1].*/
+unsigned lodepng_crc32(const unsigned char* buf, size_t len)
+{
+  return Crc32_update_crc(buf, 0xffffffffL, len) ^ 0xffffffffL;
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Reading and writing single bits and bytes from/to stream for LodePNG   / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+static unsigned char readBitFromReversedStream(size_t* bitpointer, const unsigned char* bitstream)
+{
+  unsigned char result = (unsigned char)((bitstream[(*bitpointer) >> 3] >> (7 - ((*bitpointer) & 0x7))) & 1);
+  (*bitpointer)++;
+  return result;
+}
+
+static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
+{
+  unsigned result = 0;
+  size_t i;
+  for(i = nbits - 1; i < nbits; i--)
+  {
+    result += (unsigned)readBitFromReversedStream(bitpointer, bitstream) << i;
+  }
+  return result;
+}
+
+#ifdef LODEPNG_COMPILE_DECODER
+static void setBitOfReversedStream0(size_t* bitpointer, unsigned char* bitstream, unsigned char bit)
+{
+  /*the current bit in bitstream must be 0 for this to work*/
+  if(bit)
+  {
+    /*earlier bit of huffman code is in a lesser significant bit of an earlier byte*/
+    bitstream[(*bitpointer) >> 3] |= (bit << (7 - ((*bitpointer) & 0x7)));
+  }
+  (*bitpointer)++;
+}
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+static void setBitOfReversedStream(size_t* bitpointer, unsigned char* bitstream, unsigned char bit)
+{
+  /*the current bit in bitstream may be 0 or 1 for this to work*/
+  if(bit == 0) bitstream[(*bitpointer) >> 3] &=  (unsigned char)(~(1 << (7 - ((*bitpointer) & 0x7))));
+  else         bitstream[(*bitpointer) >> 3] |=  (1 << (7 - ((*bitpointer) & 0x7)));
+  (*bitpointer)++;
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / PNG chunks                                                             / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+unsigned lodepng_chunk_length(const unsigned char* chunk)
+{
+  return lodepng_read32bitInt(&chunk[0]);
+}
+
+void lodepng_chunk_type(char type[5], const unsigned char* chunk)
+{
+  unsigned i;
+  for(i = 0; i < 4; i++) type[i] = chunk[4 + i];
+  type[4] = 0; /*null termination char*/
+}
+
+unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type)
+{
+  if(strlen(type) != 4) return 0;
+  return (chunk[4] == type[0] && chunk[5] == type[1] && chunk[6] == type[2] && chunk[7] == type[3]);
+}
+
+unsigned char lodepng_chunk_ancillary(const unsigned char* chunk)
+{
+  return((chunk[4] & 32) != 0);
+}
+
+unsigned char lodepng_chunk_private(const unsigned char* chunk)
+{
+  return((chunk[6] & 32) != 0);
+}
+
+unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk)
+{
+  return((chunk[7] & 32) != 0);
+}
+
+unsigned char* lodepng_chunk_data(unsigned char* chunk)
+{
+  return &chunk[8];
+}
+
+const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk)
+{
+  return &chunk[8];
+}
+
+unsigned lodepng_chunk_check_crc(const unsigned char* chunk)
+{
+  unsigned length = lodepng_chunk_length(chunk);
+  unsigned CRC = lodepng_read32bitInt(&chunk[length + 8]);
+  /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
+  unsigned checksum = lodepng_crc32(&chunk[4], length + 4);
+  if(CRC != checksum) return 1;
+  else return 0;
+}
+
+void lodepng_chunk_generate_crc(unsigned char* chunk)
+{
+  unsigned length = lodepng_chunk_length(chunk);
+  unsigned CRC = lodepng_crc32(&chunk[4], length + 4);
+  lodepng_set32bitInt(chunk + 8 + length, CRC);
+}
+
+unsigned char* lodepng_chunk_next(unsigned char* chunk)
+{
+  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
+  return &chunk[total_chunk_length];
+}
+
+const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk)
+{
+  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
+  return &chunk[total_chunk_length];
+}
+
+unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk)
+{
+  unsigned i;
+  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
+  unsigned char *chunk_start, *new_buffer;
+  size_t new_length = (*outlength) + total_chunk_length;
+  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/
+
+  new_buffer = (unsigned char*)myrealloc(*out, new_length);
+  if(!new_buffer) return 83; /*alloc fail*/
+  (*out) = new_buffer;
+  (*outlength) = new_length;
+  chunk_start = &(*out)[new_length - total_chunk_length];
+
+  for(i = 0; i < total_chunk_length; i++) chunk_start[i] = chunk[i];
+
+  return 0;
+}
+
+unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
+                              const char* type, const unsigned char* data)
+{
+  unsigned i;
+  unsigned char *chunk, *new_buffer;
+  size_t new_length = (*outlength) + length + 12;
+  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
+  new_buffer = (unsigned char*)myrealloc(*out, new_length);
+  if(!new_buffer) return 83; /*alloc fail*/
+  (*out) = new_buffer;
+  (*outlength) = new_length;
+  chunk = &(*out)[(*outlength) - length - 12];
+
+  /*1: length*/
+  lodepng_set32bitInt(chunk, (unsigned)length);
+
+  /*2: chunk name (4 letters)*/
+  chunk[4] = type[0];
+  chunk[5] = type[1];
+  chunk[6] = type[2];
+  chunk[7] = type[3];
+
+  /*3: the data*/
+  for(i = 0; i < length; i++) chunk[8 + i] = data[i];
+
+  /*4: CRC (of the chunkname characters and the data)*/
+  lodepng_chunk_generate_crc(chunk);
+
+  return 0;
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / Color types and such                                                   / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*return type is a LodePNG error code*/
+static unsigned checkColorValidity(LodePNGColorType colortype, unsigned bd) /*bd = bitdepth*/
+{
+  switch(colortype)
+  {
+    case 0: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; break; /*grey*/
+    case 2: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGB*/
+    case 3: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8            )) return 37; break; /*palette*/
+    case 4: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*grey + alpha*/
+    case 6: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGBA*/
+    default: return 31;
+  }
+  return 0; /*allowed color type / bits combination*/
+}
+
+static unsigned getNumColorChannels(LodePNGColorType colortype)
+{
+  switch(colortype)
+  {
+    case 0: return 1; /*grey*/
+    case 2: return 3; /*RGB*/
+    case 3: return 1; /*palette*/
+    case 4: return 2; /*grey + alpha*/
+    case 6: return 4; /*RGBA*/
+  }
+  return 0; /*unexisting color type*/
+}
+
+static unsigned lodepng_get_bpp_lct(LodePNGColorType colortype, unsigned bitdepth)
+{
+  /*bits per pixel is amount of channels * bits per channel*/
+  return getNumColorChannels(colortype) * bitdepth;
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+void lodepng_color_mode_init(LodePNGColorMode* info)
+{
+  info->key_defined = 0;
+  info->key_r = info->key_g = info->key_b = 0;
+  info->colortype = LCT_RGBA;
+  info->bitdepth = 8;
+  info->palette = 0;
+  info->palettesize = 0;
+}
+
+void lodepng_color_mode_cleanup(LodePNGColorMode* info)
+{
+  lodepng_palette_clear(info);
+}
+
+unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
+{
+  size_t i;
+  lodepng_color_mode_cleanup(dest);
+  *dest = *source;
+  if(source->palette)
+  {
+    dest->palette = (unsigned char*)mymalloc(source->palettesize * 4);
+    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
+    for(i = 0; i < source->palettesize * 4; i++) dest->palette[i] = source->palette[i];
+  }
+  return 0;
+}
+
+static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
+{
+  size_t i;
+  if(a->colortype != b->colortype) return 0;
+  if(a->bitdepth != b->bitdepth) return 0;
+  if(a->key_defined != b->key_defined) return 0;
+  if(a->key_defined)
+  {
+    if(a->key_r != b->key_r) return 0;
+    if(a->key_g != b->key_g) return 0;
+    if(a->key_b != b->key_b) return 0;
+  }
+  if(a->palettesize != b->palettesize) return 0;
+  for(i = 0; i < a->palettesize * 4; i++)
+  {
+    if(a->palette[i] != b->palette[i]) return 0;
+  }
+  return 1;
+}
+
+void lodepng_palette_clear(LodePNGColorMode* info)
+{
+  if(info->palette) myfree(info->palette);
+  info->palettesize = 0;
+}
+
+unsigned lodepng_palette_add(LodePNGColorMode* info,
+                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+  unsigned char* data;
+  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with
+  the max of 256 colors, it'll have the exact alloc size*/
+  if(!(info->palettesize & (info->palettesize - 1))) /*if palettesize is 0 or a power of two*/
+  {
+    /*allocated data must be at least 4* palettesize (for 4 color bytes)*/
+    size_t alloc_size = info->palettesize == 0 ? 4 : info->palettesize * 4 * 2;
+    data = (unsigned char*)myrealloc(info->palette, alloc_size);
+    if(!data) return 83; /*alloc fail*/
+    else info->palette = data;
+  }
+  info->palette[4 * info->palettesize + 0] = r;
+  info->palette[4 * info->palettesize + 1] = g;
+  info->palette[4 * info->palettesize + 2] = b;
+  info->palette[4 * info->palettesize + 3] = a;
+  info->palettesize++;
+  return 0;
+}
+
+unsigned lodepng_get_bpp(const LodePNGColorMode* info)
+{
+  /*calculate bits per pixel out of colortype and bitdepth*/
+  return lodepng_get_bpp_lct(info->colortype, info->bitdepth);
+}
+
+unsigned lodepng_get_channels(const LodePNGColorMode* info)
+{
+  return getNumColorChannels(info->colortype);
+}
+
+unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info)
+{
+  return info->colortype == LCT_GREY || info->colortype == LCT_GREY_ALPHA;
+}
+
+unsigned lodepng_is_alpha_type(const LodePNGColorMode* info)
+{
+  return (info->colortype & 4) != 0; /*4 or 6*/
+}
+
+unsigned lodepng_is_palette_type(const LodePNGColorMode* info)
+{
+  return info->colortype == LCT_PALETTE;
+}
+
+unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info)
+{
+  size_t i;
+  for(i = 0; i < info->palettesize; i++)
+  {
+    if(info->palette[i * 4 + 3] < 255) return 1;
+  }
+  return 0;
+}
+
+unsigned lodepng_can_have_alpha(const LodePNGColorMode* info)
+{
+  return info->key_defined
+      || lodepng_is_alpha_type(info)
+      || lodepng_has_palette_alpha(info);
+}
+
+size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color)
+{
+  return (w * h * lodepng_get_bpp(color) + 7) / 8;
+}
+
+size_t lodepng_get_raw_size_lct(unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
+{
+  return (w * h * lodepng_get_bpp_lct(colortype, bitdepth) + 7) / 8;
+}
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+
+static void LodePNGUnknownChunks_init(LodePNGInfo* info)
+{
+  unsigned i;
+  for(i = 0; i < 3; i++) info->unknown_chunks_data[i] = 0;
+  for(i = 0; i < 3; i++) info->unknown_chunks_size[i] = 0;
+}
+
+static void LodePNGUnknownChunks_cleanup(LodePNGInfo* info)
+{
+  unsigned i;
+  for(i = 0; i < 3; i++) myfree(info->unknown_chunks_data[i]);
+}
+
+static unsigned LodePNGUnknownChunks_copy(LodePNGInfo* dest, const LodePNGInfo* src)
+{
+  unsigned i;
+
+  LodePNGUnknownChunks_cleanup(dest);
+
+  for(i = 0; i < 3; i++)
+  {
+    size_t j;
+    dest->unknown_chunks_size[i] = src->unknown_chunks_size[i];
+    dest->unknown_chunks_data[i] = (unsigned char*)mymalloc(src->unknown_chunks_size[i]);
+    if(!dest->unknown_chunks_data[i] && dest->unknown_chunks_size[i]) return 83; /*alloc fail*/
+    for(j = 0; j < src->unknown_chunks_size[i]; j++)
+    {
+      dest->unknown_chunks_data[i][j] = src->unknown_chunks_data[i][j];
+    }
+  }
+
+  return 0;
+}
+
+/******************************************************************************/
+
+static void LodePNGText_init(LodePNGInfo* info)
+{
+  info->text_num = 0;
+  info->text_keys = NULL;
+  info->text_strings = NULL;
+}
+
+static void LodePNGText_cleanup(LodePNGInfo* info)
+{
+  size_t i;
+  for(i = 0; i < info->text_num; i++)
+  {
+    string_cleanup(&info->text_keys[i]);
+    string_cleanup(&info->text_strings[i]);
+  }
+  myfree(info->text_keys);
+  myfree(info->text_strings);
+}
+
+static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
+{
+  size_t i = 0;
+  dest->text_keys = 0;
+  dest->text_strings = 0;
+  dest->text_num = 0;
+  for(i = 0; i < source->text_num; i++)
+  {
+    CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i]));
+  }
+  return 0;
+}
+
+void lodepng_clear_text(LodePNGInfo* info)
+{
+  LodePNGText_cleanup(info);
+}
+
+unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
+{
+  char** new_keys = (char**)(myrealloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
+  char** new_strings = (char**)(myrealloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
+  if(!new_keys || !new_strings)
+  {
+    myfree(new_keys);
+    myfree(new_strings);
+    return 83; /*alloc fail*/
+  }
+
+  info->text_num++;
+  info->text_keys = new_keys;
+  info->text_strings = new_strings;
+
+  string_init(&info->text_keys[info->text_num - 1]);
+  string_set(&info->text_keys[info->text_num - 1], key);
+
+  string_init(&info->text_strings[info->text_num - 1]);
+  string_set(&info->text_strings[info->text_num - 1], str);
+
+  return 0;
+}
+
+/******************************************************************************/
+
+static void LodePNGIText_init(LodePNGInfo* info)
+{
+  info->itext_num = 0;
+  info->itext_keys = NULL;
+  info->itext_langtags = NULL;
+  info->itext_transkeys = NULL;
+  info->itext_strings = NULL;
+}
+
+static void LodePNGIText_cleanup(LodePNGInfo* info)
+{
+  size_t i;
+  for(i = 0; i < info->itext_num; i++)
+  {
+    string_cleanup(&info->itext_keys[i]);
+    string_cleanup(&info->itext_langtags[i]);
+    string_cleanup(&info->itext_transkeys[i]);
+    string_cleanup(&info->itext_strings[i]);
+  }
+  myfree(info->itext_keys);
+  myfree(info->itext_langtags);
+  myfree(info->itext_transkeys);
+  myfree(info->itext_strings);
+}
+
+static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
+{
+  size_t i = 0;
+  dest->itext_keys = 0;
+  dest->itext_langtags = 0;
+  dest->itext_transkeys = 0;
+  dest->itext_strings = 0;
+  dest->itext_num = 0;
+  for(i = 0; i < source->itext_num; i++)
+  {
+    CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i],
+                                        source->itext_transkeys[i], source->itext_strings[i]));
+  }
+  return 0;
+}
+
+void lodepng_clear_itext(LodePNGInfo* info)
+{
+  LodePNGIText_cleanup(info);
+}
+
+unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag,
+                           const char* transkey, const char* str)
+{
+  char** new_keys = (char**)(myrealloc(info->itext_keys, sizeof(char*) * (info->itext_num + 1)));
+  char** new_langtags = (char**)(myrealloc(info->itext_langtags, sizeof(char*) * (info->itext_num + 1)));
+  char** new_transkeys = (char**)(myrealloc(info->itext_transkeys, sizeof(char*) * (info->itext_num + 1)));
+  char** new_strings = (char**)(myrealloc(info->itext_strings, sizeof(char*) * (info->itext_num + 1)));
+  if(!new_keys || !new_langtags || !new_transkeys || !new_strings)
+  {
+    myfree(new_keys);
+    myfree(new_langtags);
+    myfree(new_transkeys);
+    myfree(new_strings);
+    return 83; /*alloc fail*/
+  }
+
+  info->itext_num++;
+  info->itext_keys = new_keys;
+  info->itext_langtags = new_langtags;
+  info->itext_transkeys = new_transkeys;
+  info->itext_strings = new_strings;
+
+  string_init(&info->itext_keys[info->itext_num - 1]);
+  string_set(&info->itext_keys[info->itext_num - 1], key);
+
+  string_init(&info->itext_langtags[info->itext_num - 1]);
+  string_set(&info->itext_langtags[info->itext_num - 1], langtag);
+
+  string_init(&info->itext_transkeys[info->itext_num - 1]);
+  string_set(&info->itext_transkeys[info->itext_num - 1], transkey);
+
+  string_init(&info->itext_strings[info->itext_num - 1]);
+  string_set(&info->itext_strings[info->itext_num - 1], str);
+
+  return 0;
+}
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+void lodepng_info_init(LodePNGInfo* info)
+{
+  lodepng_color_mode_init(&info->color);
+  info->interlace_method = 0;
+  info->compression_method = 0;
+  info->filter_method = 0;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  info->background_defined = 0;
+  info->background_r = info->background_g = info->background_b = 0;
+
+  LodePNGText_init(info);
+  LodePNGIText_init(info);
+
+  info->time_defined = 0;
+  info->phys_defined = 0;
+
+  LodePNGUnknownChunks_init(info);
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+}
+
+void lodepng_info_cleanup(LodePNGInfo* info)
+{
+  lodepng_color_mode_cleanup(&info->color);
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  LodePNGText_cleanup(info);
+  LodePNGIText_cleanup(info);
+
+  LodePNGUnknownChunks_cleanup(info);
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+}
+
+unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source)
+{
+  lodepng_info_cleanup(dest);
+  *dest = *source;
+  lodepng_color_mode_init(&dest->color);
+  CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color));
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  CERROR_TRY_RETURN(LodePNGText_copy(dest, source));
+  CERROR_TRY_RETURN(LodePNGIText_copy(dest, source));
+
+  LodePNGUnknownChunks_init(dest);
+  CERROR_TRY_RETURN(LodePNGUnknownChunks_copy(dest, source));
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+  return 0;
+}
+
+void lodepng_info_swap(LodePNGInfo* a, LodePNGInfo* b)
+{
+  LodePNGInfo temp = *a;
+  *a = *b;
+  *b = temp;
+}
+
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*index: bitgroup index, bits: bitgroup size(1, 2 or 4, in: bitgroup value, out: octet array to add bits to*/
+static void addColorBits(unsigned char* out, size_t index, unsigned bits, unsigned in)
+{
+  /*p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half*/
+  unsigned p = index % (8 / bits);
+  in &= (1 << bits) - 1; /*filter out any other bits of the input value*/
+  in = in << (bits * (8 / bits - p - 1));
+  if(p == 0) out[index * bits / 8] = in;
+  else out[index * bits / 8] |= in;
+}
+
+typedef struct ColorTree ColorTree;
+
+/*
+One node of a color tree
+This is the data structure used to count the number of unique colors and to get a palette
+index for a color. It's like an octree, but because the alpha channel is used too, each
+node has 16 instead of 8 children.
+*/
+struct ColorTree
+{
+  ColorTree* children[16]; /*up to 16 pointers to ColorTree of next level*/
+  int index; /*the payload. Only has a meaningful value if this is in the last level*/
+};
+
+static void color_tree_init(ColorTree* tree)
+{
+  int i;
+  for(i = 0; i < 16; i++) tree->children[i] = 0;
+  tree->index = -1;
+}
+
+static void color_tree_cleanup(ColorTree* tree)
+{
+  int i;
+  for(i = 0; i < 16; i++)
+  {
+    if(tree->children[i])
+    {
+      color_tree_cleanup(tree->children[i]);
+      myfree(tree->children[i]);
+    }
+  }
+}
+
+/*returns -1 if color not present, its index otherwise*/
+static int color_tree_get(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+  int bit = 0;
+  for(bit = 0; bit < 8; bit++)
+  {
+    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
+    if(!tree->children[i]) return -1;
+    else tree = tree->children[i];
+  }
+  return tree ? tree->index : -1;
+}
+
+#ifdef LODEPNG_COMPILE_ENCODER
+static int color_tree_has(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+  return color_tree_get(tree, r, g, b, a) >= 0;
+}
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+/*color is not allowed to already exist.
+Index should be >= 0 (it's signed to be compatible with using -1 for "doesn't exist")*/
+static void color_tree_add(ColorTree* tree,
+                           unsigned char r, unsigned char g, unsigned char b, unsigned char a, int index)
+{
+  int bit;
+  for(bit = 0; bit < 8; bit++)
+  {
+    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
+    if(!tree->children[i])
+    {
+      tree->children[i] = (ColorTree*)mymalloc(sizeof(ColorTree));
+      color_tree_init(tree->children[i]);
+    }
+    tree = tree->children[i];
+  }
+  tree->index = index;
+}
+
+/*put a pixel, given its RGBA color, into image of any color type*/
+static unsigned rgba8ToPixel(unsigned char* out, size_t i,
+                             const LodePNGColorMode* mode, ColorTree* tree /*for palette*/,
+                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+  if(mode->colortype == LCT_GREY)
+  {
+    unsigned char grey = r; /*((unsigned short)r + g + b) / 3*/;
+    if(mode->bitdepth == 8) out[i] = grey;
+    else if(mode->bitdepth == 16) out[i * 2 + 0] = out[i * 2 + 1] = grey;
+    else
+    {
+      /*take the most significant bits of grey*/
+      grey = (grey >> (8 - mode->bitdepth)) & ((1 << mode->bitdepth) - 1);
+      addColorBits(out, i, mode->bitdepth, grey);
+    }
+  }
+  else if(mode->colortype == LCT_RGB)
+  {
+    if(mode->bitdepth == 8)
+    {
+      out[i * 3 + 0] = r;
+      out[i * 3 + 1] = g;
+      out[i * 3 + 2] = b;
+    }
+    else
+    {
+      out[i * 6 + 0] = out[i * 6 + 1] = r;
+      out[i * 6 + 2] = out[i * 6 + 3] = g;
+      out[i * 6 + 4] = out[i * 6 + 5] = b;
+    }
+  }
+  else if(mode->colortype == LCT_PALETTE)
+  {
+    int index = color_tree_get(tree, r, g, b, a);
+    if(index < 0) return 82; /*color not in palette*/
+    if(mode->bitdepth == 8) out[i] = index;
+    else addColorBits(out, i, mode->bitdepth, index);
+  }
+  else if(mode->colortype == LCT_GREY_ALPHA)
+  {
+    unsigned char grey = r; /*((unsigned short)r + g + b) / 3*/;
+    if(mode->bitdepth == 8)
+    {
+      out[i * 2 + 0] = grey;
+      out[i * 2 + 1] = a;
+    }
+    else if(mode->bitdepth == 16)
+    {
+      out[i * 4 + 0] = out[i * 4 + 1] = grey;
+      out[i * 4 + 2] = out[i * 4 + 3] = a;
+    }
+  }
+  else if(mode->colortype == LCT_RGBA)
+  {
+    if(mode->bitdepth == 8)
+    {
+      out[i * 4 + 0] = r;
+      out[i * 4 + 1] = g;
+      out[i * 4 + 2] = b;
+      out[i * 4 + 3] = a;
+    }
+    else
+    {
+      out[i * 8 + 0] = out[i * 8 + 1] = r;
+      out[i * 8 + 2] = out[i * 8 + 3] = g;
+      out[i * 8 + 4] = out[i * 8 + 5] = b;
+      out[i * 8 + 6] = out[i * 8 + 7] = a;
+    }
+  }
+
+  return 0; /*no error*/
+}
+
+/*put a pixel, given its RGBA16 color, into image of any color 16-bitdepth type*/
+static unsigned rgba16ToPixel(unsigned char* out, size_t i,
+                              const LodePNGColorMode* mode,
+                              unsigned short r, unsigned short g, unsigned short b, unsigned short a)
+{
+  if(mode->bitdepth != 16) return 85; /*must be 16 for this function*/
+  if(mode->colortype == LCT_GREY)
+  {
+    unsigned short grey = r; /*((unsigned)r + g + b) / 3*/;
+    out[i * 2 + 0] = (grey >> 8) & 255;
+    out[i * 2 + 1] = grey & 255;
+  }
+  else if(mode->colortype == LCT_RGB)
+  {
+    out[i * 6 + 0] = (r >> 8) & 255;
+    out[i * 6 + 1] = r & 255;
+    out[i * 6 + 2] = (g >> 8) & 255;
+    out[i * 6 + 3] = g & 255;
+    out[i * 6 + 4] = (b >> 8) & 255;
+    out[i * 6 + 5] = b & 255;
+  }
+  else if(mode->colortype == LCT_GREY_ALPHA)
+  {
+    unsigned short grey = r; /*((unsigned)r + g + b) / 3*/;
+    out[i * 4 + 0] = (grey >> 8) & 255;
+    out[i * 4 + 1] = grey & 255;
+    out[i * 4 + 2] = (a >> 8) & 255;
+    out[i * 4 + 3] = a & 255;
+  }
+  else if(mode->colortype == LCT_RGBA)
+  {
+    out[i * 8 + 0] = (r >> 8) & 255;
+    out[i * 8 + 1] = r & 255;
+    out[i * 8 + 2] = (g >> 8) & 255;
+    out[i * 8 + 3] = g & 255;
+    out[i * 8 + 4] = (b >> 8) & 255;
+    out[i * 8 + 5] = b & 255;
+    out[i * 8 + 6] = (a >> 8) & 255;
+    out[i * 8 + 7] = a & 255;
+  }
+
+  return 0; /*no error*/
+}
+
+/*Get RGBA8 color of pixel with index i (y * width + x) from the raw image with given color type.*/
+static unsigned getPixelColorRGBA8(unsigned char* r, unsigned char* g,
+                                   unsigned char* b, unsigned char* a,
+                                   const unsigned char* in, size_t i,
+                                   const LodePNGColorMode* mode)
+{
+  if(mode->colortype == LCT_GREY)
+  {
+    if(mode->bitdepth == 8)
+    {
+      *r = *g = *b = in[i];
+      if(mode->key_defined && *r == mode->key_r) *a = 0;
+      else *a = 255;
+    }
+    else if(mode->bitdepth == 16)
+    {
+      *r = *g = *b = in[i * 2 + 0];
+      if(mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r) *a = 0;
+      else *a = 255;
+    }
+    else
+    {
+      unsigned highest = ((1U << mode->bitdepth) - 1U); /*highest possible value for this bit depth*/
+      size_t j = i * mode->bitdepth;
+      unsigned value = readBitsFromReversedStream(&j, in, mode->bitdepth);
+      *r = *g = *b = (value * 255) / highest;
+      if(mode->key_defined && value == mode->key_r) *a = 0;
+      else *a = 255;
+    }
+  }
+  else if(mode->colortype == LCT_RGB)
+  {
+    if(mode->bitdepth == 8)
+    {
+      *r = in[i * 3 + 0]; *g = in[i * 3 + 1]; *b = in[i * 3 + 2];
+      if(mode->key_defined && *r == mode->key_r && *g == mode->key_g && *b == mode->key_b) *a = 0;
+      else *a = 255;
+    }
+    else
+    {
+      *r = in[i * 6 + 0];
+      *g = in[i * 6 + 2];
+      *b = in[i * 6 + 4];
+      if(mode->key_defined && 256U * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r
+         && 256U * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g
+         && 256U * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b) *a = 0;
+      else *a = 255;
+    }
+  }
+  else if(mode->colortype == LCT_PALETTE)
+  {
+    unsigned index;
+    if(mode->bitdepth == 8) index = in[i];
+    else
+    {
+      size_t j = i * mode->bitdepth;
+      index = readBitsFromReversedStream(&j, in, mode->bitdepth);
+    }
+    if(index >= mode->palettesize) return 47; /*index out of palette*/
+    *r = mode->palette[index * 4 + 0];
+    *g = mode->palette[index * 4 + 1];
+    *b = mode->palette[index * 4 + 2];
+    *a = mode->palette[index * 4 + 3];
+  }
+  else if(mode->colortype == LCT_GREY_ALPHA)
+  {
+    if(mode->bitdepth == 8)
+    {
+      *r = *g = *b = in[i * 2 + 0];
+      *a = in[i * 2 + 1];
+    }
+    else
+    {
+      *r = *g = *b = in[i * 4 + 0];
+      *a = in[i * 4 + 2];
+    }
+  }
+  else if(mode->colortype == LCT_RGBA)
+  {
+    if(mode->bitdepth == 8)
+    {
+      *r = in[i * 4 + 0];
+      *g = in[i * 4 + 1];
+      *b = in[i * 4 + 2];
+      *a = in[i * 4 + 3];
+    }
+    else
+    {
+      *r = in[i * 8 + 0];
+      *g = in[i * 8 + 2];
+      *b = in[i * 8 + 4];
+      *a = in[i * 8 + 6];
+    }
+  }
+
+  return 0; /*no error*/
+}
+
+/*Similar to getPixelColorRGBA8, but with all the for loops inside of the color
+mode test cases, optimized to convert the colors much faster, when converting
+to RGBA or RGB with 8 bit per cannel. buffer must be RGBA or RGB output with
+enough memory, if has_alpha is true the output is RGBA. mode has the color mode
+of the input buffer.*/
+static unsigned getPixelColorsRGBA8(unsigned char* buffer, size_t numpixels,
+                                    unsigned has_alpha, const unsigned char* in,
+                                    const LodePNGColorMode* mode)
+{
+  unsigned num_channels = has_alpha ? 4 : 3;
+  size_t i;
+  if(mode->colortype == LCT_GREY)
+  {
+    if(mode->bitdepth == 8)
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = buffer[1] = buffer[2] = in[i];
+        if(has_alpha) buffer[3] = mode->key_defined && in[i] == mode->key_r ? 0 : 255;
+      }
+    }
+    else if(mode->bitdepth == 16)
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = buffer[1] = buffer[2] = in[i * 2];
+        if(has_alpha) buffer[3] = mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r ? 0 : 255;
+      }
+    }
+    else
+    {
+      unsigned highest = ((1U << mode->bitdepth) - 1U); /*highest possible value for this bit depth*/
+      size_t j = 0;
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        unsigned value = readBitsFromReversedStream(&j, in, mode->bitdepth);
+        buffer[0] = buffer[1] = buffer[2] = (value * 255) / highest;
+        if(has_alpha) buffer[3] = mode->key_defined && value == mode->key_r ? 0 : 255;
+      }
+    }
+  }
+  else if(mode->colortype == LCT_RGB)
+  {
+    if(mode->bitdepth == 8)
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = in[i * 3 + 0];
+        buffer[1] = in[i * 3 + 1];
+        buffer[2] = in[i * 3 + 2];
+        if(has_alpha) buffer[3] = mode->key_defined && buffer[0] == mode->key_r
+           && buffer[1]== mode->key_g && buffer[2] == mode->key_b ? 0 : 255;
+      }
+    }
+    else
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = in[i * 6 + 0];
+        buffer[1] = in[i * 6 + 2];
+        buffer[2] = in[i * 6 + 4];
+        if(has_alpha) buffer[3] = mode->key_defined
+           && 256U * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r
+           && 256U * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g
+           && 256U * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b ? 0 : 255;
+      }
+    }
+  }
+  else if(mode->colortype == LCT_PALETTE)
+  {
+    unsigned index;
+    size_t j = 0;
+    for(i = 0; i < numpixels; i++, buffer += num_channels)
+    {
+      if(mode->bitdepth == 8) index = in[i];
+      else index = readBitsFromReversedStream(&j, in, mode->bitdepth);
+      if(index >= mode->palettesize) return 47; /*index out of palette*/
+      buffer[0] = mode->palette[index * 4 + 0];
+      buffer[1] = mode->palette[index * 4 + 1];
+      buffer[2] = mode->palette[index * 4 + 2];
+      if(has_alpha) buffer[3] = mode->palette[index * 4 + 3];
+    }
+  }
+  else if(mode->colortype == LCT_GREY_ALPHA)
+  {
+    if(mode->bitdepth == 8)
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = buffer[1] = buffer[2] = in[i * 2 + 0];
+        if(has_alpha) buffer[3] = in[i * 2 + 1];
+      }
+    }
+    else
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = buffer[1] = buffer[2] = in[i * 4 + 0];
+        if(has_alpha) buffer[3] = in[i * 4 + 2];
+      }
+    }
+  }
+  else if(mode->colortype == LCT_RGBA)
+  {
+    if(mode->bitdepth == 8)
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = in[i * 4 + 0];
+        buffer[1] = in[i * 4 + 1];
+        buffer[2] = in[i * 4 + 2];
+        if(has_alpha) buffer[3] = in[i * 4 + 3];
+      }
+    }
+    else
+    {
+      for(i = 0; i < numpixels; i++, buffer += num_channels)
+      {
+        buffer[0] = in[i * 8 + 0];
+        buffer[1] = in[i * 8 + 2];
+        buffer[2] = in[i * 8 + 4];
+        if(has_alpha) buffer[3] = in[i * 8 + 6];
+      }
+    }
+  }
+
+  return 0; /*no error*/
+}
+
+/*Get RGBA16 color of pixel with index i (y * width + x) from the raw image with
+given color type, but the given color type must be 16-bit itself.*/
+static unsigned getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a,
+                                    const unsigned char* in, size_t i, const LodePNGColorMode* mode)
+{
+  if(mode->bitdepth != 16) return 85; /*error: this function only supports 16-bit input*/
+
+  if(mode->colortype == LCT_GREY)
+  {
+    *r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1];
+    if(mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r) *a = 0;
+    else *a = 65535;
+  }
+  else if(mode->colortype == LCT_RGB)
+  {
+    *r = 256 * in[i * 6 + 0] + in[i * 6 + 1];
+    *g = 256 * in[i * 6 + 2] + in[i * 6 + 3];
+    *b = 256 * in[i * 6 + 4] + in[i * 6 + 5];
+    if(mode->key_defined && 256U * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r
+       && 256U * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g
+       && 256U * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b) *a = 0;
+    else *a = 65535;
+  }
+  else if(mode->colortype == LCT_GREY_ALPHA)
+  {
+    *r = *g = *b = 256 * in[i * 4 + 0] + in[i * 4 + 1];
+    *a = 256 * in[i * 4 + 2] + in[i * 4 + 3];
+  }
+  else if(mode->colortype == LCT_RGBA)
+  {
+    *r = 256 * in[i * 8 + 0] + in[i * 8 + 1];
+    *g = 256 * in[i * 8 + 2] + in[i * 8 + 3];
+    *b = 256 * in[i * 8 + 4] + in[i * 8 + 5];
+    *a = 256 * in[i * 8 + 6] + in[i * 8 + 7];
+  }
+  else return 85; /*error: this function only supports 16-bit input, not palettes*/
+
+  return 0; /*no error*/
+}
+
+/*
+converts from any color type to 24-bit or 32-bit (later maybe more supported). return value = LodePNG error code
+the out buffer must have (w * h * bpp + 7) / 8 bytes, where bpp is the bits per pixel of the output color type
+(lodepng_get_bpp) for < 8 bpp images, there may _not_ be padding bits at the end of scanlines.
+*/
+unsigned lodepng_convert(unsigned char* out, const unsigned char* in,
+                         LodePNGColorMode* mode_out, LodePNGColorMode* mode_in,
+                         unsigned w, unsigned h)
+{
+  unsigned error = 0;
+  size_t i;
+  ColorTree tree;
+  size_t numpixels = w * h;
+
+  if(lodepng_color_mode_equal(mode_out, mode_in))
+  {
+    size_t numbytes = lodepng_get_raw_size(w, h, mode_in);
+    for(i = 0; i < numbytes; i++) out[i] = in[i];
+    return error;
+  }
+
+  if(mode_out->colortype == LCT_PALETTE)
+  {
+    size_t palsize = 1 << mode_out->bitdepth;
+    if(mode_out->palettesize < palsize) palsize = mode_out->palettesize;
+    color_tree_init(&tree);
+    for(i = 0; i < palsize; i++)
+    {
+      unsigned char* p = &mode_out->palette[i * 4];
+      color_tree_add(&tree, p[0], p[1], p[2], p[3], i);
+    }
+  }
+
+  if(mode_in->bitdepth == 16 && mode_out->bitdepth == 16)
+  {
+    for(i = 0; i < numpixels; i++)
+    {
+      unsigned short r = 0, g = 0, b = 0, a = 0;
+      error = getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode_in);
+      if(error) break;
+      error = rgba16ToPixel(out, i, mode_out, r, g, b, a);
+      if(error) break;
+    }
+  }
+  else if(mode_out->bitdepth == 8 && mode_out->colortype == LCT_RGBA)
+  {
+    error = getPixelColorsRGBA8(out, numpixels, 1, in, mode_in);
+  }
+  else if(mode_out->bitdepth == 8 && mode_out->colortype == LCT_RGB)
+  {
+    error = getPixelColorsRGBA8(out, numpixels, 0, in, mode_in);
+  }
+  else
+  {
+    unsigned char r = 0, g = 0, b = 0, a = 0;
+    for(i = 0; i < numpixels; i++)
+    {
+      error = getPixelColorRGBA8(&r, &g, &b, &a, in, i, mode_in);
+      if(error) break;
+      error = rgba8ToPixel(out, i, mode_out, &tree, r, g, b, a);
+      if(error) break;
+    }
+  }
+
+  if(mode_out->colortype == LCT_PALETTE)
+  {
+    color_tree_cleanup(&tree);
+  }
+
+  return error;
+}
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+typedef struct ColorProfile
+{
+  unsigned char sixteenbit; /*needs more than 8 bits per channel*/
+  unsigned char sixteenbit_done;
+
+
+  unsigned char colored; /*not greyscale*/
+  unsigned char colored_done;
+
+  unsigned char key; /*a color key is required, or more*/
+  unsigned short key_r; /*these values are always in 16-bit bitdepth in the profile*/
+  unsigned short key_g;
+  unsigned short key_b;
+  unsigned char alpha; /*alpha channel, or alpha palette, required*/
+  unsigned char alpha_done;
+
+  unsigned numcolors;
+  ColorTree tree; /*for listing the counted colors, up to 256*/
+  unsigned char* palette; /*size 1024. Remember up to the first 256 RGBA colors*/
+  unsigned maxnumcolors; /*if more than that amount counted*/
+  unsigned char numcolors_done;
+
+  unsigned greybits; /*amount of bits required for greyscale (1, 2, 4, 8). Does not take 16 bit into account.*/
+  unsigned char greybits_done;
+
+} ColorProfile;
+
+static void color_profile_init(ColorProfile* profile, LodePNGColorMode* mode)
+{
+  profile->sixteenbit = 0;
+  profile->sixteenbit_done = mode->bitdepth == 16 ? 0 : 1;
+
+  profile->colored = 0;
+  profile->colored_done = lodepng_is_greyscale_type(mode) ? 1 : 0;
+
+  profile->key = 0;
+  profile->alpha = 0;
+  profile->alpha_done = lodepng_can_have_alpha(mode) ? 0 : 1;
+
+  profile->numcolors = 0;
+  color_tree_init(&profile->tree);
+  profile->palette = (unsigned char*)mymalloc(1024);
+  profile->maxnumcolors = 257;
+  if(lodepng_get_bpp(mode) <= 8)
+  {
+    int bpp = lodepng_get_bpp(mode);
+    profile->maxnumcolors = bpp == 1 ? 2 : (bpp == 2 ? 4 : (bpp == 4 ? 16 : 256));
+  }
+  profile->numcolors_done = 0;
+
+  profile->greybits = 1;
+  profile->greybits_done = lodepng_get_bpp(mode) == 1 ? 1 : 0;
+}
+
+static void color_profile_cleanup(ColorProfile* profile)
+{
+  color_tree_cleanup(&profile->tree);
+  myfree(profile->palette);
+}
+
+/*function used for debug purposes with C++*/
+/*void printColorProfile(ColorProfile* p)
+{
+  std::cout << "sixteenbit: " << (int)p->sixteenbit << std::endl;
+  std::cout << "sixteenbit_done: " << (int)p->sixteenbit_done << std::endl;
+  std::cout << "colored: " << (int)p->colored << std::endl;
+  std::cout << "colored_done: " << (int)p->colored_done << std::endl;
+  std::cout << "key: " << (int)p->key << std::endl;
+  std::cout << "key_r: " << (int)p->key_r << std::endl;
+  std::cout << "key_g: " << (int)p->key_g << std::endl;
+  std::cout << "key_b: " << (int)p->key_b << std::endl;
+  std::cout << "alpha: " << (int)p->alpha << std::endl;
+  std::cout << "alpha_done: " << (int)p->alpha_done << std::endl;
+  std::cout << "numcolors: " << (int)p->numcolors << std::endl;
+  std::cout << "maxnumcolors: " << (int)p->maxnumcolors << std::endl;
+  std::cout << "numcolors_done: " << (int)p->numcolors_done << std::endl;
+  std::cout << "greybits: " << (int)p->greybits << std::endl;
+  std::cout << "greybits_done: " << (int)p->greybits_done << std::endl;
+}*/
+
+/*Returns how many bits needed to represent given value (max 8 bit)*/
+unsigned getValueRequiredBits(unsigned short value)
+{
+  if(value == 0 || value == 255) return 1;
+  /*The scaling of 2-bit and 4-bit values uses multiples of 85 and 17*/
+  if(value % 17 == 0) return value % 85 == 0 ? 2 : 4;
+  return 8;
+}
+
+/*profile must already have been inited with mode.
+It's ok to set some parameters of profile to done already.*/
+static unsigned get_color_profile(ColorProfile* profile,
+                                  const unsigned char* in, size_t numpixels,
+                                  LodePNGColorMode* mode)
+{
+  unsigned error = 0;
+  size_t i;
+
+  if(mode->bitdepth == 16)
+  {
+    for(i = 0; i < numpixels; i++)
+    {
+      unsigned short r, g, b, a;
+      error = getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode);
+      if(error) break;
+
+      /*a color is considered good for 8-bit if the first byte and the second byte are equal,
+        (so if it's divisible through 257), NOT necessarily if the second byte is 0*/
+      if(!profile->sixteenbit_done
+          && (((r & 255) != ((r >> 8) & 255))
+           || ((g & 255) != ((g >> 8) & 255))
+           || ((b & 255) != ((b >> 8) & 255))))
+      {
+        profile->sixteenbit = 1;
+        profile->sixteenbit_done = 1;
+        profile->greybits_done = 1; /*greybits is not applicable anymore at 16-bit*/
+        profile->numcolors_done = 1; /*counting colors no longer useful, palette doesn't support 16-bit*/
+      }
+
+      if(!profile->colored_done && (r != g || r != b))
+      {
+        profile->colored = 1;
+        profile->colored_done = 1;
+        profile->greybits_done = 1; /*greybits is not applicable anymore*/
+      }
+
+      if(!profile->alpha_done && a != 65535)
+      {
+        if(a == 0 && !(profile->key && (r != profile->key_r || g != profile->key_g || b != profile->key_b)))
+        {
+          if(!profile->key)
+          {
+            profile->key = 1;
+            profile->key_r = r;
+            profile->key_g = g;
+            profile->key_b = b;
+          }
+        }
+        else
+        {
+          profile->alpha = 1;
+          profile->alpha_done = 1;
+          profile->greybits_done = 1; /*greybits is not applicable anymore*/
+        }
+      }
+
+      /* Color key cannot be used if an opaque pixel also has that RGB color. */
+      if(!profile->alpha_done && a == 65535 && profile->key
+          && r == profile->key_r && g == profile->key_g && b == profile->key_b)
+      {
+          profile->alpha = 1;
+          profile->alpha_done = 1;
+          profile->greybits_done = 1; /*greybits is not applicable anymore*/
+      }
+
+      if(!profile->greybits_done)
+      {
+        /*assuming 8-bit r, this test does not care about 16-bit*/
+        unsigned bits = getValueRequiredBits(r);
+        if(bits > profile->greybits) profile->greybits = bits;
+        if(profile->greybits >= 8) profile->greybits_done = 1;
+      }
+
+      if(!profile->numcolors_done)
+      {
+        /*assuming 8-bit rgba, this test does not care about 16-bit*/
+        if(!color_tree_has(&profile->tree, (unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a))
+        {
+          color_tree_add(&profile->tree, (unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a,
+            profile->numcolors);
+          if(profile->numcolors < 256)
+          {
+            unsigned char* p = profile->palette;
+            unsigned i = profile->numcolors;
+            p[i * 4 + 0] = (unsigned char)r;
+            p[i * 4 + 1] = (unsigned char)g;
+            p[i * 4 + 2] = (unsigned char)b;
+            p[i * 4 + 3] = (unsigned char)a;
+          }
+          profile->numcolors++;
+          if(profile->numcolors >= profile->maxnumcolors) profile->numcolors_done = 1;
+        }
+      }
+
+      if(profile->alpha_done && profile->numcolors_done
+      && profile->colored_done && profile->sixteenbit_done && profile->greybits_done)
+      {
+        break;
+      }
+    };
+  }
+  else /* < 16-bit */
+  {
+    for(i = 0; i < numpixels; i++)
+    {
+      unsigned char r = 0, g = 0, b = 0, a = 0;
+      error = getPixelColorRGBA8(&r, &g, &b, &a, in, i, mode);
+      if(error) break;
+
+      if(!profile->colored_done && (r != g || r != b))
+      {
+        profile->colored = 1;
+        profile->colored_done = 1;
+        profile->greybits_done = 1; /*greybits is not applicable anymore*/
+      }
+
+      if(!profile->alpha_done && a != 255)
+      {
+        if(a == 0 && !(profile->key && (r != profile->key_r || g != profile->key_g || b != profile->key_b)))
+        {
+          if(!profile->key)
+          {
+            profile->key = 1;
+            profile->key_r = r;
+            profile->key_g = g;
+            profile->key_b = b;
+          }
+        }
+        else
+        {
+          profile->alpha = 1;
+          profile->alpha_done = 1;
+          profile->greybits_done = 1; /*greybits is not applicable anymore*/
+        }
+      }
+
+      /* Color key cannot be used if an opaque pixel also has that RGB color. */
+      if(!profile->alpha_done && a == 255 && profile->key
+          && r == profile->key_r && g == profile->key_g && b == profile->key_b)
+      {
+          profile->alpha = 1;
+          profile->alpha_done = 1;
+          profile->greybits_done = 1; /*greybits is not applicable anymore*/
+      }
+
+      if(!profile->greybits_done)
+      {
+        unsigned bits = getValueRequiredBits(r);
+        if(bits > profile->greybits) profile->greybits = bits;
+        if(profile->greybits >= 8) profile->greybits_done = 1;
+      }
+
+      if(!profile->numcolors_done)
+      {
+        if(!color_tree_has(&profile->tree, r, g, b, a))
+        {
+
+          color_tree_add(&profile->tree, r, g, b, a, profile->numcolors);
+          if(profile->numcolors < 256)
+          {
+            unsigned char* p = profile->palette;
+            unsigned i = profile->numcolors;
+            p[i * 4 + 0] = r;
+            p[i * 4 + 1] = g;
+            p[i * 4 + 2] = b;
+            p[i * 4 + 3] = a;
+          }
+          profile->numcolors++;
+          if(profile->numcolors >= profile->maxnumcolors) profile->numcolors_done = 1;
+        }
+      }
+
+      if(profile->alpha_done && profile->numcolors_done && profile->colored_done && profile->greybits_done)
+      {
+        break;
+      }
+    };
+  }
+
+  /*make the profile's key always 16-bit for consistency*/
+  if(mode->bitdepth < 16)
+  {
+    /*repeat each byte twice*/
+    profile->key_r *= 257;
+    profile->key_g *= 257;
+    profile->key_b *= 257;
+  }
+
+  return error;
+}
+
+/*updates values of mode with a potentially smaller color model. mode_out should
+contain the user chosen color model, but will be overwritten with the new chosen one.*/
+static unsigned doAutoChooseColor(LodePNGColorMode* mode_out,
+                                  const unsigned char* image, unsigned w, unsigned h, LodePNGColorMode* mode_in,
+                                  LodePNGAutoConvert auto_convert)
+{
+  ColorProfile profile;
+  unsigned error = 0;
+  int no_nibbles = auto_convert == LAC_AUTO_NO_NIBBLES || auto_convert == LAC_AUTO_NO_NIBBLES_NO_PALETTE;
+  int no_palette = auto_convert == LAC_AUTO_NO_PALETTE || auto_convert == LAC_AUTO_NO_NIBBLES_NO_PALETTE;
+
+  if(auto_convert == LAC_ALPHA)
+  {
+    if(mode_out->colortype != LCT_RGBA && mode_out->colortype != LCT_GREY_ALPHA) return 0;
+  }
+
+  color_profile_init(&profile, mode_in);
+  if(auto_convert == LAC_ALPHA)
+  {
+    profile.colored_done = 1;
+    profile.greybits_done = 1;
+    profile.numcolors_done = 1;
+    profile.sixteenbit_done = 1;
+  }
+  error = get_color_profile(&profile, image, w * h, mode_in);
+
+  if(!error && auto_convert == LAC_ALPHA)
+  {
+    if(!profile.alpha)
+    {
+      mode_out->colortype = (mode_out->colortype == LCT_RGBA ? LCT_RGB : LCT_GREY);
+    }
+  }
+  else if(!error && auto_convert != LAC_ALPHA)
+  {
+    mode_out->key_defined = 0;
+
+    if(profile.sixteenbit)
+    {
+      mode_out->bitdepth = 16;
+      if(profile.alpha)
+      {
+        mode_out->colortype = profile.colored ? LCT_RGBA : LCT_GREY_ALPHA;
+      }
+      else
+      {
+        mode_out->colortype = profile.colored ? LCT_RGB : LCT_GREY;
+        if(profile.key)
+        {
+          mode_out->key_defined = 1;
+          mode_out->key_r = profile.key_r;
+          mode_out->key_g = profile.key_g;
+          mode_out->key_b = profile.key_b;
+        }
+      }
+    }
+    else /*less than 16 bits per channel*/
+    {
+      /*don't add palette overhead if image hasn't got a lot of pixels*/
+      unsigned n = profile.numcolors;
+      int palette_ok = !no_palette && n <= 256 && (n * 2 < w * h);
+      unsigned palettebits = n <= 2 ? 1 : (n <= 4 ? 2 : (n <= 16 ? 4 : 8));
+      int grey_ok = !profile.colored && !profile.alpha; /*grey without alpha, with potentially low bits*/
+      if(palette_ok || grey_ok)
+      {
+        if(!palette_ok || (grey_ok && profile.greybits <= palettebits))
+        {
+          mode_out->colortype = LCT_GREY;
+          mode_out->bitdepth = profile.greybits;
+          if(profile.key)
+          {
+            unsigned keyval = profile.key_r;
+            keyval &= (profile.greybits - 1); /*same subgroup of bits repeated, so taking right bits is fine*/
+            mode_out->key_defined = 1;
+            mode_out->key_r = keyval;
+            mode_out->key_g = keyval;
+            mode_out->key_b = keyval;
+          }
+        }
+        else
+        {
+          /*fill in the palette*/
+          unsigned i;
+          unsigned char* p = profile.palette;
+          for(i = 0; i < profile.numcolors; i++)
+          {
+            error = lodepng_palette_add(mode_out, p[i * 4 + 0], p[i * 4 + 1], p[i * 4 + 2], p[i * 4 + 3]);
+            if(error) break;
+          }
+
+          mode_out->colortype = LCT_PALETTE;
+          mode_out->bitdepth = palettebits;
+        }
+      }
+      else /*8-bit per channel*/
+      {
+        mode_out->bitdepth = 8;
+        if(profile.alpha)
+        {
+          mode_out->colortype = profile.colored ? LCT_RGBA : LCT_GREY_ALPHA;
+        }
+        else
+        {
+          mode_out->colortype = profile.colored ? LCT_RGB : LCT_GREY /*LCT_GREY normally won't occur, already done earlier*/;
+          if(profile.key)
+          {
+            mode_out->key_defined = 1;
+            mode_out->key_r = profile.key_r % 256;
+            mode_out->key_g = profile.key_g % 256;
+            mode_out->key_b = profile.key_b % 256;
+          }
+        }
+      }
+    }
+  }
+
+  color_profile_cleanup(&profile);
+
+  if(mode_out->colortype == LCT_PALETTE && mode_in->palettesize == mode_out->palettesize)
+  {
+    /*In this case keep the palette order of the input, so that the user can choose an optimal one*/
+    size_t i;
+    for(i = 0; i < mode_in->palettesize * 4; i++)
+    {
+      mode_out->palette[i] = mode_in->palette[i];
+    }
+  }
+
+  if(no_nibbles && mode_out->bitdepth < 8)
+  {
+    /*palette can keep its small amount of colors, as long as no indices use it*/
+    mode_out->bitdepth = 8;
+  }
+
+  return error;
+}
+
+#endif /* #ifdef LODEPNG_COMPILE_ENCODER */
+
+/*
+Paeth predicter, used by PNG filter type 4
+The parameters are of type short, but should come from unsigned chars, the shorts
+are only needed to make the paeth calculation correct.
+*/
+static unsigned char paethPredictor(short a, short b, short c)
+{
+  short pa = abs(b - c);
+  short pb = abs(a - c);
+  short pc = abs(a + b - c - c);
+
+  if(pc < pa && pc < pb) return (unsigned char)c;
+  else if(pb < pa) return (unsigned char)b;
+  else return (unsigned char)a;
+}
+
+/*shared values used by multiple Adam7 related functions*/
+
+static const unsigned ADAM7_IX[7] = { 0, 4, 0, 2, 0, 1, 0 }; /*x start values*/
+static const unsigned ADAM7_IY[7] = { 0, 0, 4, 0, 2, 0, 1 }; /*y start values*/
+static const unsigned ADAM7_DX[7] = { 8, 8, 4, 4, 2, 2, 1 }; /*x delta values*/
+static const unsigned ADAM7_DY[7] = { 8, 8, 8, 4, 4, 2, 2 }; /*y delta values*/
+
+/*
+Outputs various dimensions and positions in the image related to the Adam7 reduced images.
+passw: output containing the width of the 7 passes
+passh: output containing the height of the 7 passes
+filter_passstart: output containing the index of the start and end of each
+ reduced image with filter bytes
+padded_passstart output containing the index of the start and end of each
+ reduced image when without filter bytes but with padded scanlines
+passstart: output containing the index of the start and end of each reduced
+ image without padding between scanlines, but still padding between the images
+w, h: width and height of non-interlaced image
+bpp: bits per pixel
+"padded" is only relevant if bpp is less than 8 and a scanline or image does not
+ end at a full byte
+*/
+static void Adam7_getpassvalues(unsigned passw[7], unsigned passh[7], size_t filter_passstart[8],
+                                size_t padded_passstart[8], size_t passstart[8], unsigned w, unsigned h, unsigned bpp)
+{
+  /*the passstart values have 8 values: the 8th one indicates the byte after the end of the 7th (= last) pass*/
+  unsigned i;
+
+  /*calculate width and height in pixels of each pass*/
+  for(i = 0; i < 7; i++)
+  {
+    passw[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) / ADAM7_DX[i];
+    passh[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) / ADAM7_DY[i];
+    if(passw[i] == 0) passh[i] = 0;
+    if(passh[i] == 0) passw[i] = 0;
+  }
+
+  filter_passstart[0] = padded_passstart[0] = passstart[0] = 0;
+  for(i = 0; i < 7; i++)
+  {
+    /*if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte)*/
+    filter_passstart[i + 1] = filter_passstart[i]
+                            + ((passw[i] && passh[i]) ? passh[i] * (1 + (passw[i] * bpp + 7) / 8) : 0);
+    /*bits padded if needed to fill full byte at end of each scanline*/
+    padded_passstart[i + 1] = padded_passstart[i] + passh[i] * ((passw[i] * bpp + 7) / 8);
+    /*only padded at end of reduced image*/
+    passstart[i + 1] = passstart[i] + (passh[i] * passw[i] * bpp + 7) / 8;
+  }
+}
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / PNG Decoder                                                            / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*read the information from the header and store it in the LodePNGInfo. return value is error*/
+unsigned lodepng_inspect(unsigned* w, unsigned* h, LodePNGState* state,
+                         const unsigned char* in, size_t insize)
+{
+  LodePNGInfo* info = &state->info_png;
+  if(insize == 0 || in == 0)
+  {
+    CERROR_RETURN_ERROR(state->error, 48); /*error: the given data is empty*/
+  }
+  if(insize < 29)
+  {
+    CERROR_RETURN_ERROR(state->error, 27); /*error: the data length is smaller than the length of a PNG header*/
+  }
+
+  /*when decoding a new PNG image, make sure all parameters created after previous decoding are reset*/
+  lodepng_info_cleanup(info);
+  lodepng_info_init(info);
+
+  if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71
+     || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10)
+  {
+    CERROR_RETURN_ERROR(state->error, 28); /*error: the first 8 bytes are not the correct PNG signature*/
+  }
+  if(in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R')
+  {
+    CERROR_RETURN_ERROR(state->error, 29); /*error: it doesn't start with a IHDR chunk!*/
+  }
+
+  /*read the values given in the header*/
+  *w = lodepng_read32bitInt(&in[16]);
+  *h = lodepng_read32bitInt(&in[20]);
+  info->color.bitdepth = in[24];
+  info->color.colortype = (LodePNGColorType)in[25];
+  info->compression_method = in[26];
+  info->filter_method = in[27];
+  info->interlace_method = in[28];
+
+  if(!state->decoder.ignore_crc)
+  {
+    unsigned CRC = lodepng_read32bitInt(&in[29]);
+    unsigned checksum = lodepng_crc32(&in[12], 17);
+    if(CRC != checksum)
+    {
+      CERROR_RETURN_ERROR(state->error, 57); /*invalid CRC*/
+    }
+  }
+
+  /*error: only compression method 0 is allowed in the specification*/
+  if(info->compression_method != 0) CERROR_RETURN_ERROR(state->error, 32);
+  /*error: only filter method 0 is allowed in the specification*/
+  if(info->filter_method != 0) CERROR_RETURN_ERROR(state->error, 33);
+  /*error: only interlace methods 0 and 1 exist in the specification*/
+  if(info->interlace_method > 1) CERROR_RETURN_ERROR(state->error, 34);
+
+  state->error = checkColorValidity(info->color.colortype, info->color.bitdepth);
+  return state->error;
+}
+
+static unsigned unfilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon,
+                                 size_t bytewidth, unsigned char filterType, size_t length)
+{
+  /*
+  For PNG filter method 0
+  unfilter a PNG image scanline by scanline. when the pixels are smaller than 1 byte,
+  the filter works byte per byte (bytewidth = 1)
+  precon is the previous unfiltered scanline, recon the result, scanline the current one
+  the incoming scanlines do NOT include the filtertype byte, that one is given in the parameter filterType instead
+  recon and scanline MAY be the same memory address! precon must be disjoint.
+  */
+
+  size_t i;
+  switch(filterType)
+  {
+    case 0:
+      for(i = 0; i < length; i++) recon[i] = scanline[i];
+      break;
+    case 1:
+      for(i = 0; i < bytewidth; i++) recon[i] = scanline[i];
+      for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth];
+      break;
+    case 2:
+      if(precon)
+      {
+        for(i = 0; i < length; i++) recon[i] = scanline[i] + precon[i];
+      }
+      else
+      {
+        for(i = 0; i < length; i++) recon[i] = scanline[i];
+      }
+      break;
+    case 3:
+      if(precon)
+      {
+        for(i = 0; i < bytewidth; i++) recon[i] = scanline[i] + precon[i] / 2;
+        for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) / 2);
+      }
+      else
+      {
+        for(i = 0; i < bytewidth; i++) recon[i] = scanline[i];
+        for(i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth] / 2;
+      }
+      break;
+    case 4:
+      if(precon)
+      {
+        for(i = 0; i < bytewidth; i++)
+        {
+          recon[i] = (scanline[i] + precon[i]); /*paethPredictor(0, precon[i], 0) is always precon[i]*/
+        }
+        for(i = bytewidth; i < length; i++)
+        {
+          recon[i] = (scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]));
+        }
+      }
+      else
+      {
+        for(i = 0; i < bytewidth; i++)
+        {
+          recon[i] = scanline[i];
+        }
+        for(i = bytewidth; i < length; i++)
+        {
+          /*paethPredictor(recon[i - bytewidth], 0, 0) is always recon[i - bytewidth]*/
+          recon[i] = (scanline[i] + recon[i - bytewidth]);
+        }
+      }
+      break;
+    default: return 36; /*error: unexisting filter type given*/
+  }
+  return 0;
+}
+
+static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
+{
+  /*
+  For PNG filter method 0
+  this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times)
+  out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline
+  w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel
+  in and out are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes)
+  */
+
+  unsigned y;
+  unsigned char* prevline = 0;
+
+  /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
+  size_t bytewidth = (bpp + 7) / 8;
+  size_t linebytes = (w * bpp + 7) / 8;
+
+  for(y = 0; y < h; y++)
+  {
+    size_t outindex = linebytes * y;
+    size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
+    unsigned char filterType = in[inindex];
+
+    CERROR_TRY_RETURN(unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes));
+
+    prevline = &out[outindex];
+  }
+
+  return 0;
+}
+
+/*
+in: Adam7 interlaced image, with no padding bits between scanlines, but between
+ reduced images so that each reduced image starts at a byte.
+out: the same pixels, but re-ordered so that they're now a non-interlaced image with size w*h
+bpp: bits per pixel
+out has the following size in bits: w * h * bpp.
+in is possibly bigger due to padding bits between reduced images.
+out must be big enough AND must be 0 everywhere if bpp < 8 in the current implementation
+(because that's likely a little bit faster)
+NOTE: comments about padding bits are only relevant if bpp < 8
+*/
+static void Adam7_deinterlace(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
+{
+  unsigned passw[7], passh[7];
+  size_t filter_passstart[8], padded_passstart[8], passstart[8];
+  unsigned i;
+
+  Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
+
+  if(bpp >= 8)
+  {
+    for(i = 0; i < 7; i++)
+    {
+      unsigned x, y, b;
+      size_t bytewidth = bpp / 8;
+      for(y = 0; y < passh[i]; y++)
+      for(x = 0; x < passw[i]; x++)
+      {
+        size_t pixelinstart = passstart[i] + (y * passw[i] + x) * bytewidth;
+        size_t pixeloutstart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * bytewidth;
+        for(b = 0; b < bytewidth; b++)
+        {
+          out[pixeloutstart + b] = in[pixelinstart + b];
+        }
+      }
+    }
+  }
+  else /*bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers*/
+  {
+    for(i = 0; i < 7; i++)
+    {
+      unsigned x, y, b;
+      unsigned ilinebits = bpp * passw[i];
+      unsigned olinebits = bpp * w;
+      size_t obp, ibp; /*bit pointers (for out and in buffer)*/
+      for(y = 0; y < passh[i]; y++)
+      for(x = 0; x < passw[i]; x++)
+      {
+        ibp = (8 * passstart[i]) + (y * ilinebits + x * bpp);
+        obp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp;
+        for(b = 0; b < bpp; b++)
+        {
+          unsigned char bit = readBitFromReversedStream(&ibp, in);
+          /*note that this function assumes the out buffer is completely 0, use setBitOfReversedStream otherwise*/
+          setBitOfReversedStream0(&obp, out, bit);
+        }
+      }
+    }
+  }
+}
+
+static void removePaddingBits(unsigned char* out, const unsigned char* in,
+                              size_t olinebits, size_t ilinebits, unsigned h)
+{
+  /*
+  After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need
+  to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers
+  for the Adam7 code, the color convert code and the output to the user.
+  in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must
+  have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
+  also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
+  only useful if (ilinebits - olinebits) is a value in the range 1..7
+  */
+  unsigned y;
+  size_t diff = ilinebits - olinebits;
+  size_t ibp = 0, obp = 0; /*input and output bit pointers*/
+  for(y = 0; y < h; y++)
+  {
+    size_t x;
+    for(x = 0; x < olinebits; x++)
+    {
+      unsigned char bit = readBitFromReversedStream(&ibp, in);
+      setBitOfReversedStream(&obp, out, bit);
+    }
+    ibp += diff;
+  }
+}
+
+/*out must be buffer big enough to contain full image, and in must contain the full decompressed data from
+the IDAT chunks (with filter index bytes and possible padding bits)
+return value is error*/
+static unsigned postProcessScanlines(unsigned char* out, unsigned char* in,
+                                     unsigned w, unsigned h, const LodePNGInfo* info_png)
+{
+  /*
+  This function converts the filtered-padded-interlaced data into pure 2D image buffer with the PNG's colortype.
+  Steps:
+  *) if no Adam7: 1) unfilter 2) remove padding bits (= posible extra bits per scanline if bpp < 8)
+  *) if adam7: 1) 7x unfilter 2) 7x remove padding bits 3) Adam7_deinterlace
+  NOTE: the in buffer will be overwritten with intermediate data!
+  */
+  unsigned bpp = lodepng_get_bpp(&info_png->color);
+  if(bpp == 0) return 31; /*error: invalid colortype*/
+
+  if(info_png->interlace_method == 0)
+  {
+    if(bpp < 8 && w * bpp != ((w * bpp + 7) / 8) * 8)
+    {
+      CERROR_TRY_RETURN(unfilter(in, in, w, h, bpp));
+      removePaddingBits(out, in, w * bpp, ((w * bpp + 7) / 8) * 8, h);
+    }
+    /*we can immediatly filter into the out buffer, no other steps needed*/
+    else CERROR_TRY_RETURN(unfilter(out, in, w, h, bpp));
+  }
+  else /*interlace_method is 1 (Adam7)*/
+  {
+    unsigned passw[7], passh[7]; size_t filter_passstart[8], padded_passstart[8], passstart[8];
+    unsigned i;
+
+    Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
+
+    for(i = 0; i < 7; i++)
+    {
+      CERROR_TRY_RETURN(unfilter(&in[padded_passstart[i]], &in[filter_passstart[i]], passw[i], passh[i], bpp));
+      /*TODO: possible efficiency improvement: if in this reduced image the bits fit nicely in 1 scanline,
+      move bytes instead of bits or move not at all*/
+      if(bpp < 8)
+      {
+        /*remove padding bits in scanlines; after this there still may be padding
+        bits between the different reduced images: each reduced image still starts nicely at a byte*/
+        removePaddingBits(&in[passstart[i]], &in[padded_passstart[i]], passw[i] * bpp,
+                          ((passw[i] * bpp + 7) / 8) * 8, passh[i]);
+      }
+    }
+
+    Adam7_deinterlace(out, in, w, h, bpp);
+  }
+
+  return 0;
+}
+
+static unsigned readChunk_PLTE(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
+{
+  unsigned pos = 0, i;
+  if(color->palette) myfree(color->palette);
+  color->palettesize = chunkLength / 3;
+  color->palette = (unsigned char*)mymalloc(4 * color->palettesize);
+  if(!color->palette && color->palettesize)
+  {
+    color->palettesize = 0;
+    return 83; /*alloc fail*/
+  }
+  if(color->palettesize > 256) return 38; /*error: palette too big*/
+
+  for(i = 0; i < color->palettesize; i++)
+  {
+    color->palette[4 * i + 0] = data[pos++]; /*R*/
+    color->palette[4 * i + 1] = data[pos++]; /*G*/
+    color->palette[4 * i + 2] = data[pos++]; /*B*/
+    color->palette[4 * i + 3] = 255; /*alpha*/
+  }
+
+  return 0; /* OK */
+}
+
+static unsigned readChunk_tRNS(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
+{
+  unsigned i;
+  if(color->colortype == LCT_PALETTE)
+  {
+    /*error: more alpha values given than there are palette entries*/
+    if(chunkLength > color->palettesize) return 38;
+
+    for(i = 0; i < chunkLength; i++) color->palette[4 * i + 3] = data[i];
+  }
+  else if(color->colortype == LCT_GREY)
+  {
+    /*error: this chunk must be 2 bytes for greyscale image*/
+    if(chunkLength != 2) return 30;
+
+    color->key_defined = 1;
+    color->key_r = color->key_g = color->key_b = 256 * data[0] + data[1];
+  }
+  else if(color->colortype == LCT_RGB)
+  {
+    /*error: this chunk must be 6 bytes for RGB image*/
+    if(chunkLength != 6) return 41;
+
+    color->key_defined = 1;
+    color->key_r = 256 * data[0] + data[1];
+    color->key_g = 256 * data[2] + data[3];
+    color->key_b = 256 * data[4] + data[5];
+  }
+  else return 42; /*error: tRNS chunk not allowed for other color models*/
+
+  return 0; /* OK */
+}
+
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+/*background color chunk (bKGD)*/
+static unsigned readChunk_bKGD(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
+{
+  if(info->color.colortype == LCT_PALETTE)
+  {
+    /*error: this chunk must be 1 byte for indexed color image*/
+    if(chunkLength != 1) return 43;
+
+    info->background_defined = 1;
+    info->background_r = info->background_g = info->background_b = data[0];
+  }
+  else if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
+  {
+    /*error: this chunk must be 2 bytes for greyscale image*/
+    if(chunkLength != 2) return 44;
+
+    info->background_defined = 1;
+    info->background_r = info->background_g = info->background_b
+                                 = 256 * data[0] + data[1];
+  }
+  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
+  {
+    /*error: this chunk must be 6 bytes for greyscale image*/
+    if(chunkLength != 6) return 45;
+
+    info->background_defined = 1;
+    info->background_r = 256 * data[0] + data[1];
+    info->background_g = 256 * data[2] + data[3];
+    info->background_b = 256 * data[4] + data[5];
+  }
+
+  return 0; /* OK */
+}
+
+/*text chunk (tEXt)*/
+static unsigned readChunk_tEXt(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
+{
+  unsigned error = 0;
+  char *key = 0, *str = 0;
+  unsigned i;
+
+  while(!error) /*not really a while loop, only used to break on error*/
+  {
+    unsigned length, string2_begin;
+
+    length = 0;
+    while(length < chunkLength && data[length] != 0) length++;
+    /*even though it's not allowed by the standard, no error is thrown if
+    there's no null termination char, if the text is empty*/
+    if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/
+
+    key = (char*)mymalloc(length + 1);
+    if(!key) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    key[length] = 0;
+    for(i = 0; i < length; i++) key[i] = data[i];
+
+    string2_begin = length + 1; /*skip keyword null terminator*/
+
+    length = chunkLength < string2_begin ? 0 : chunkLength - string2_begin;
+    str = (char*)mymalloc(length + 1);
+    if(!str) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    str[length] = 0;
+    for(i = 0; i < length; i++) str[i] = data[string2_begin + i];
+
+    error = lodepng_add_text(info, key, str);
+
+    break;
+  }
+
+  myfree(key);
+  myfree(str);
+
+  return error;
+}
+
+/*compressed text chunk (zTXt)*/
+static unsigned readChunk_zTXt(LodePNGInfo* info, const LodePNGDecompressSettings* zlibsettings,
+                               const unsigned char* data, size_t chunkLength)
+{
+  unsigned error = 0;
+  unsigned i;
+
+  unsigned length, string2_begin;
+  char *key = 0;
+  ucvector decoded;
+
+  ucvector_init(&decoded);
+
+  while(!error) /*not really a while loop, only used to break on error*/
+  {
+    for(length = 0; length < chunkLength && data[length] != 0; length++) ;
+    if(length + 2 >= chunkLength) CERROR_BREAK(error, 75); /*no null termination, corrupt?*/
+    if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/
+
+    key = (char*)mymalloc(length + 1);
+    if(!key) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    key[length] = 0;
+    for(i = 0; i < length; i++) key[i] = data[i];
+
+    if(data[length + 1] != 0) CERROR_BREAK(error, 72); /*the 0 byte indicating compression must be 0*/
+
+    string2_begin = length + 2;
+    if(string2_begin > chunkLength) CERROR_BREAK(error, 75); /*no null termination, corrupt?*/
+
+    length = chunkLength - string2_begin;
+    /*will fail if zlib error, e.g. if length is too small*/
+    error = zlib_decompress(&decoded.data, &decoded.size,
+                            (unsigned char*)(&data[string2_begin]),
+                            length, zlibsettings);
+    if(error) break;
+    ucvector_push_back(&decoded, 0);
+
+    error = lodepng_add_text(info, key, (char*)decoded.data);
+
+    break;
+  }
+
+  myfree(key);
+  ucvector_cleanup(&decoded);
+
+  return error;
+}
+
+/*international text chunk (iTXt)*/
+static unsigned readChunk_iTXt(LodePNGInfo* info, const LodePNGDecompressSettings* zlibsettings,
+                               const unsigned char* data, size_t chunkLength)
+{
+  unsigned error = 0;
+  unsigned i;
+
+  unsigned length, begin, compressed;
+  char *key = 0, *langtag = 0, *transkey = 0;
+  ucvector decoded;
+  ucvector_init(&decoded);
+
+  while(!error) /*not really a while loop, only used to break on error*/
+  {
+    /*Quick check if the chunk length isn't too small. Even without check
+    it'd still fail with other error checks below if it's too short. This just gives a different error code.*/
+    if(chunkLength < 5) CERROR_BREAK(error, 30); /*iTXt chunk too short*/
+
+    /*read the key*/
+    for(length = 0; length < chunkLength && data[length] != 0; length++) ;
+    if(length + 3 >= chunkLength) CERROR_BREAK(error, 75); /*no null termination char, corrupt?*/
+    if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/
+
+    key = (char*)mymalloc(length + 1);
+    if(!key) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    key[length] = 0;
+    for(i = 0; i < length; i++) key[i] = data[i];
+
+    /*read the compression method*/
+    compressed = data[length + 1];
+    if(data[length + 2] != 0) CERROR_BREAK(error, 72); /*the 0 byte indicating compression must be 0*/
+
+    /*even though it's not allowed by the standard, no error is thrown if
+    there's no null termination char, if the text is empty for the next 3 texts*/
+
+    /*read the langtag*/
+    begin = length + 3;
+    length = 0;
+    for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
+
+    langtag = (char*)mymalloc(length + 1);
+    if(!langtag) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    langtag[length] = 0;
+    for(i = 0; i < length; i++) langtag[i] = data[begin + i];
+
+    /*read the transkey*/
+    begin += length + 1;
+    length = 0;
+    for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
+
+    transkey = (char*)mymalloc(length + 1);
+    if(!transkey) CERROR_BREAK(error, 83); /*alloc fail*/
+
+    transkey[length] = 0;
+    for(i = 0; i < length; i++) transkey[i] = data[begin + i];
+
+    /*read the actual text*/
+    begin += length + 1;
+
+    length = chunkLength < begin ? 0 : chunkLength - begin;
+
+    if(compressed)
+    {
+      /*will fail if zlib error, e.g. if length is too small*/
+      error = zlib_decompress(&decoded.data, &decoded.size,
+                              (unsigned char*)(&data[begin]),
+                              length, zlibsettings);
+      if(error) break;
+      if(decoded.allocsize < decoded.size) decoded.allocsize = decoded.size;
+      ucvector_push_back(&decoded, 0);
+    }
+    else
+    {
+      if(!ucvector_resize(&decoded, length + 1)) CERROR_BREAK(error, 83 /*alloc fail*/);
+
+      decoded.data[length] = 0;
+      for(i = 0; i < length; i++) decoded.data[i] = data[begin + i];
+    }
+
+    error = lodepng_add_itext(info, key, langtag, transkey, (char*)decoded.data);
+
+    break;
+  }
+
+  myfree(key);
+  myfree(langtag);
+  myfree(transkey);
+  ucvector_cleanup(&decoded);
+
+  return error;
+}
+
+static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
+{
+  if(chunkLength != 7) return 73; /*invalid tIME chunk size*/
+
+  info->time_defined = 1;
+  info->time.year = 256 * data[0] + data[+ 1];
+  info->time.month = data[2];
+  info->time.day = data[3];
+  info->time.hour = data[4];
+  info->time.minute = data[5];
+  info->time.second = data[6];
+
+  return 0; /* OK */
+}
+
+static unsigned readChunk_pHYs(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
+{
+  if(chunkLength != 9) return 74; /*invalid pHYs chunk size*/
+
+  info->phys_defined = 1;
+  info->phys_x = 16777216 * data[0] + 65536 * data[1] + 256 * data[2] + data[3];
+  info->phys_y = 16777216 * data[4] + 65536 * data[5] + 256 * data[6] + data[7];
+  info->phys_unit = data[8];
+
+  return 0; /* OK */
+}
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+/*read a PNG, the result will be in the same color type as the PNG (hence "generic")*/
+static void decodeGeneric(unsigned char** out, unsigned* w, unsigned* h,
+                          LodePNGState* state,
+                          const unsigned char* in, size_t insize)
+{
+  unsigned char IEND = 0;
+  const unsigned char* chunk;
+  size_t i;
+  ucvector idat; /*the data from idat chunks*/
+
+  /*for unknown chunk order*/
+  unsigned unknown = 0;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  unsigned critical_pos = 1; /*1 = after IHDR, 2 = after PLTE, 3 = after IDAT*/
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+  /*provide some proper output values if error will happen*/
+  *out = 0;
+
+  state->error = lodepng_inspect(w, h, state, in, insize); /*reads header and resets other parameters in state->info_png*/
+  if(state->error) return;
+
+  ucvector_init(&idat);
+  chunk = &in[33]; /*first byte of the first chunk after the header*/
+
+  /*loop through the chunks, ignoring unknown chunks and stopping at IEND chunk.
+  IDAT data is put at the start of the in buffer*/
+  while(!IEND && !state->error)
+  {
+    unsigned chunkLength;
+    const unsigned char* data; /*the data in the chunk*/
+
+    /*error: size of the in buffer too small to contain next chunk*/
+    if((size_t)((chunk - in) + 12) > insize || chunk < in) CERROR_BREAK(state->error, 30);
+
+    /*length of the data of the chunk, excluding the length bytes, chunk type and CRC bytes*/
+    chunkLength = lodepng_chunk_length(chunk);
+    /*error: chunk length larger than the max PNG chunk size*/
+    if(chunkLength > 2147483647) CERROR_BREAK(state->error, 63);
+
+    if((size_t)((chunk - in) + chunkLength + 12) > insize || (chunk + chunkLength + 12) < in)
+    {
+      CERROR_BREAK(state->error, 64); /*error: size of the in buffer too small to contain next chunk*/
+    }
+
+    data = lodepng_chunk_data_const(chunk);
+
+    /*IDAT chunk, containing compressed image data*/
+    if(lodepng_chunk_type_equals(chunk, "IDAT"))
+    {
+      size_t oldsize = idat.size;
+      if(!ucvector_resize(&idat, oldsize + chunkLength)) CERROR_BREAK(state->error, 83 /*alloc fail*/);
+      for(i = 0; i < chunkLength; i++) idat.data[oldsize + i] = data[i];
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+      critical_pos = 3;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    }
+    /*IEND chunk*/
+    else if(lodepng_chunk_type_equals(chunk, "IEND"))
+    {
+      IEND = 1;
+    }
+    /*palette chunk (PLTE)*/
+    else if(lodepng_chunk_type_equals(chunk, "PLTE"))
+    {
+      state->error = readChunk_PLTE(&state->info_png.color, data, chunkLength);
+      if(state->error) break;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+      critical_pos = 2;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    }
+    /*palette transparency chunk (tRNS)*/
+    else if(lodepng_chunk_type_equals(chunk, "tRNS"))
+    {
+      state->error = readChunk_tRNS(&state->info_png.color, data, chunkLength);
+      if(state->error) break;
+    }
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+    /*background color chunk (bKGD)*/
+    else if(lodepng_chunk_type_equals(chunk, "bKGD"))
+    {
+      state->error = readChunk_bKGD(&state->info_png, data, chunkLength);
+      if(state->error) break;
+    }
+    /*text chunk (tEXt)*/
+    else if(lodepng_chunk_type_equals(chunk, "tEXt"))
+    {
+      if(state->decoder.read_text_chunks)
+      {
+        state->error = readChunk_tEXt(&state->info_png, data, chunkLength);
+        if(state->error) break;
+      }
+    }
+    /*compressed text chunk (zTXt)*/
+    else if(lodepng_chunk_type_equals(chunk, "zTXt"))
+    {
+      if(state->decoder.read_text_chunks)
+      {
+        state->error = readChunk_zTXt(&state->info_png, &state->decoder.zlibsettings, data, chunkLength);
+        if(state->error) break;
+      }
+    }
+    /*international text chunk (iTXt)*/
+    else if(lodepng_chunk_type_equals(chunk, "iTXt"))
+    {
+      if(state->decoder.read_text_chunks)
+      {
+        state->error = readChunk_iTXt(&state->info_png, &state->decoder.zlibsettings, data, chunkLength);
+        if(state->error) break;
+      }
+    }
+    else if(lodepng_chunk_type_equals(chunk, "tIME"))
+    {
+      state->error = readChunk_tIME(&state->info_png, data, chunkLength);
+      if(state->error) break;
+    }
+    else if(lodepng_chunk_type_equals(chunk, "pHYs"))
+    {
+      state->error = readChunk_pHYs(&state->info_png, data, chunkLength);
+      if(state->error) break;
+    }
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    else /*it's not an implemented chunk type, so ignore it: skip over the data*/
+    {
+      /*error: unknown critical chunk (5th bit of first byte of chunk type is 0)*/
+      if(!lodepng_chunk_ancillary(chunk)) CERROR_BREAK(state->error, 69);
+
+      unknown = 1;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+      if(state->decoder.remember_unknown_chunks)
+      {
+        state->error = lodepng_chunk_append(&state->info_png.unknown_chunks_data[critical_pos - 1],
+                                            &state->info_png.unknown_chunks_size[critical_pos - 1], chunk);
+        if(state->error) break;
+      }
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    }
+
+    if(!state->decoder.ignore_crc && !unknown) /*check CRC if wanted, only on known chunk types*/
+    {
+      if(lodepng_chunk_check_crc(chunk)) CERROR_BREAK(state->error, 57); /*invalid CRC*/
+    }
+
+    if(!IEND) chunk = lodepng_chunk_next_const(chunk);
+  }
+
+  if(!state->error)
+  {
+    ucvector scanlines;
+    ucvector_init(&scanlines);
+
+    /*maximum final image length is already reserved in the vector's length - this is not really necessary*/
+    if(!ucvector_resize(&scanlines, lodepng_get_raw_size(*w, *h, &state->info_png.color) + *h))
+    {
+      state->error = 83; /*alloc fail*/
+    }
+    if(!state->error)
+    {
+      /*decompress with the Zlib decompressor*/
+      state->error = zlib_decompress(&scanlines.data, &scanlines.size, idat.data,
+                                     idat.size, &state->decoder.zlibsettings);
+    }
+
+    if(!state->error)
+    {
+      ucvector outv;
+      ucvector_init(&outv);
+      if(!ucvector_resizev(&outv,
+          lodepng_get_raw_size(*w, *h, &state->info_png.color), 0)) state->error = 83; /*alloc fail*/
+      if(!state->error) state->error = postProcessScanlines(outv.data, scanlines.data, *w, *h, &state->info_png);
+      *out = outv.data;
+    }
+    ucvector_cleanup(&scanlines);
+  }
+
+  ucvector_cleanup(&idat);
+}
+
+unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h,
+                        LodePNGState* state,
+                        const unsigned char* in, size_t insize)
+{
+  *out = 0;
+  decodeGeneric(out, w, h, state, in, insize);
+  if(state->error) return state->error;
+  if(!state->decoder.color_convert || lodepng_color_mode_equal(&state->info_raw, &state->info_png.color))
+  {
+    /*same color type, no copying or converting of data needed*/
+    /*store the info_png color settings on the info_raw so that the info_raw still reflects what colortype
+    the raw image has to the end user*/
+    if(!state->decoder.color_convert)
+    {
+      state->error = lodepng_color_mode_copy(&state->info_raw, &state->info_png.color);
+      if(state->error) return state->error;
+    }
+  }
+  else
+  {
+    /*color conversion needed; sort of copy of the data*/
+    unsigned char* data = *out;
+    size_t outsize;
+
+    /*TODO: check if this works according to the statement in the documentation: "The converter can convert
+    from greyscale input color type, to 8-bit greyscale or greyscale with alpha"*/
+    if(!(state->info_raw.colortype == LCT_RGB || state->info_raw.colortype == LCT_RGBA)
+       && !(state->info_raw.bitdepth == 8))
+    {
+      return 56; /*unsupported color mode conversion*/
+    }
+
+    outsize = lodepng_get_raw_size(*w, *h, &state->info_raw);
+    *out = (unsigned char*)mymalloc(outsize);
+    if(!(*out))
+    {
+      state->error = 83; /*alloc fail*/
+    }
+    else state->error = lodepng_convert(*out, data, &state->info_raw, &state->info_png.color, *w, *h);
+    myfree(data);
+  }
+  return state->error;
+}
+
+unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in,
+                               size_t insize, LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned error;
+  LodePNGState state;
+  lodepng_state_init(&state);
+  state.info_raw.colortype = colortype;
+  state.info_raw.bitdepth = bitdepth;
+  error = lodepng_decode(out, w, h, &state, in, insize);
+  lodepng_state_cleanup(&state);
+  return error;
+}
+
+unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize)
+{
+  return lodepng_decode_memory(out, w, h, in, insize, LCT_RGBA, 8);
+}
+
+unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize)
+{
+  return lodepng_decode_memory(out, w, h, in, insize, LCT_RGB, 8);
+}
+
+#ifdef LODEPNG_COMPILE_DISK
+unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename,
+                             LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned char* buffer;
+  size_t buffersize;
+  unsigned error;
+  error = lodepng_load_file(&buffer, &buffersize, filename);
+  if(!error) error = lodepng_decode_memory(out, w, h, buffer, buffersize, colortype, bitdepth);
+  myfree(buffer);
+  return error;
+}
+
+unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename)
+{
+  return lodepng_decode_file(out, w, h, filename, LCT_RGBA, 8);
+}
+
+unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename)
+{
+  return lodepng_decode_file(out, w, h, filename, LCT_RGB, 8);
+}
+#endif /*LODEPNG_COMPILE_DISK*/
+
+void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings)
+{
+  settings->color_convert = 1;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  settings->read_text_chunks = 1;
+  settings->remember_unknown_chunks = 0;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+  settings->ignore_crc = 0;
+  lodepng_decompress_settings_init(&settings->zlibsettings);
+}
+
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER)
+
+void lodepng_state_init(LodePNGState* state)
+{
+#ifdef LODEPNG_COMPILE_DECODER
+  lodepng_decoder_settings_init(&state->decoder);
+#endif /*LODEPNG_COMPILE_DECODER*/
+#ifdef LODEPNG_COMPILE_ENCODER
+  lodepng_encoder_settings_init(&state->encoder);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+  lodepng_color_mode_init(&state->info_raw);
+  lodepng_info_init(&state->info_png);
+  state->error = 1;
+}
+
+void lodepng_state_cleanup(LodePNGState* state)
+{
+  lodepng_color_mode_cleanup(&state->info_raw);
+  lodepng_info_cleanup(&state->info_png);
+}
+
+void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source)
+{
+  lodepng_state_cleanup(dest);
+  *dest = *source;
+  lodepng_color_mode_init(&dest->info_raw);
+  lodepng_info_init(&dest->info_png);
+  dest->error = lodepng_color_mode_copy(&dest->info_raw, &source->info_raw); if(dest->error) return;
+  dest->error = lodepng_info_copy(&dest->info_png, &source->info_png); if(dest->error) return;
+}
+
+#endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */
+
+#ifdef LODEPNG_COMPILE_ENCODER
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* / PNG Encoder                                                            / */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+/*chunkName must be string of 4 characters*/
+static unsigned addChunk(ucvector* out, const char* chunkName, const unsigned char* data, size_t length)
+{
+  CERROR_TRY_RETURN(lodepng_chunk_create(&out->data, &out->size, (unsigned)length, chunkName, data));
+  out->allocsize = out->size; /*fix the allocsize again*/
+  return 0;
+}
+
+static void writeSignature(ucvector* out)
+{
+  /*8 bytes PNG signature, aka the magic bytes*/
+  ucvector_push_back(out, 137);
+  ucvector_push_back(out, 80);
+  ucvector_push_back(out, 78);
+  ucvector_push_back(out, 71);
+  ucvector_push_back(out, 13);
+  ucvector_push_back(out, 10);
+  ucvector_push_back(out, 26);
+  ucvector_push_back(out, 10);
+}
+
+static unsigned addChunk_IHDR(ucvector* out, unsigned w, unsigned h,
+                              LodePNGColorType colortype, unsigned bitdepth, unsigned interlace_method)
+{
+  unsigned error = 0;
+  ucvector header;
+  ucvector_init(&header);
+
+  lodepng_add32bitInt(&header, w); /*width*/
+  lodepng_add32bitInt(&header, h); /*height*/
+  ucvector_push_back(&header, (unsigned char)bitdepth); /*bit depth*/
+  ucvector_push_back(&header, (unsigned char)colortype); /*color type*/
+  ucvector_push_back(&header, 0); /*compression method*/
+  ucvector_push_back(&header, 0); /*filter method*/
+  ucvector_push_back(&header, interlace_method); /*interlace method*/
+
+  error = addChunk(out, "IHDR", header.data, header.size);
+  ucvector_cleanup(&header);
+
+  return error;
+}
+
+static unsigned addChunk_PLTE(ucvector* out, const LodePNGColorMode* info)
+{
+  unsigned error = 0;
+  size_t i;
+  ucvector PLTE;
+  ucvector_init(&PLTE);
+  for(i = 0; i < info->palettesize * 4; i++)
+  {
+    /*add all channels except alpha channel*/
+    if(i % 4 != 3) ucvector_push_back(&PLTE, info->palette[i]);
+  }
+  error = addChunk(out, "PLTE", PLTE.data, PLTE.size);
+  ucvector_cleanup(&PLTE);
+
+  return error;
+}
+
+static unsigned addChunk_tRNS(ucvector* out, const LodePNGColorMode* info)
+{
+  unsigned error = 0;
+  size_t i;
+  ucvector tRNS;
+  ucvector_init(&tRNS);
+  if(info->colortype == LCT_PALETTE)
+  {
+    size_t amount = info->palettesize;
+    /*the tail of palette values that all have 255 as alpha, does not have to be encoded*/
+    for(i = info->palettesize; i > 0; i--)
+    {
+      if(info->palette[4 * (i - 1) + 3] == 255) amount--;
+      else break;
+    }
+    /*add only alpha channel*/
+    for(i = 0; i < amount; i++) ucvector_push_back(&tRNS, info->palette[4 * i + 3]);
+  }
+  else if(info->colortype == LCT_GREY)
+  {
+    if(info->key_defined)
+    {
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_r / 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_r % 256));
+    }
+  }
+  else if(info->colortype == LCT_RGB)
+  {
+    if(info->key_defined)
+    {
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_r / 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_r % 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_g / 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_g % 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_b / 256));
+      ucvector_push_back(&tRNS, (unsigned char)(info->key_b % 256));
+    }
+  }
+
+  error = addChunk(out, "tRNS", tRNS.data, tRNS.size);
+  ucvector_cleanup(&tRNS);
+
+  return error;
+}
+
+static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize,
+                              LodePNGCompressSettings* zlibsettings)
+{
+  ucvector zlibdata;
+  unsigned error = 0;
+
+  /*compress with the Zlib compressor*/
+  ucvector_init(&zlibdata);
+  error = zlib_compress(&zlibdata.data, &zlibdata.size, data, datasize, zlibsettings);
+  if(!error) error = addChunk(out, "IDAT", zlibdata.data, zlibdata.size);
+  ucvector_cleanup(&zlibdata);
+
+  return error;
+}
+
+static unsigned addChunk_IEND(ucvector* out)
+{
+  unsigned error = 0;
+  error = addChunk(out, "IEND", 0, 0);
+  return error;
+}
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+
+static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring)
+{
+  unsigned error = 0;
+  size_t i;
+  ucvector text;
+  ucvector_init(&text);
+  for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&text, (unsigned char)keyword[i]);
+  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
+  ucvector_push_back(&text, 0); /*0 termination char*/
+  for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&text, (unsigned char)textstring[i]);
+  error = addChunk(out, "tEXt", text.data, text.size);
+  ucvector_cleanup(&text);
+
+  return error;
+}
+
+static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring,
+                              LodePNGCompressSettings* zlibsettings)
+{
+  unsigned error = 0;
+  ucvector data, compressed;
+  size_t i, textsize = strlen(textstring);
+
+  ucvector_init(&data);
+  ucvector_init(&compressed);
+  for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&data, (unsigned char)keyword[i]);
+  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
+  ucvector_push_back(&data, 0); /*0 termination char*/
+  ucvector_push_back(&data, 0); /*compression method: 0*/
+
+  error = zlib_compress(&compressed.data, &compressed.size,
+                        (unsigned char*)textstring, textsize, zlibsettings);
+  if(!error)
+  {
+    for(i = 0; i < compressed.size; i++) ucvector_push_back(&data, compressed.data[i]);
+    error = addChunk(out, "zTXt", data.data, data.size);
+  }
+
+  ucvector_cleanup(&compressed);
+  ucvector_cleanup(&data);
+  return error;
+}
+
+static unsigned addChunk_iTXt(ucvector* out, unsigned compressed, const char* keyword, const char* langtag,
+                              const char* transkey, const char* textstring, LodePNGCompressSettings* zlibsettings)
+{
+  unsigned error = 0;
+  ucvector data;
+  size_t i, textsize = strlen(textstring);
+
+  ucvector_init(&data);
+
+  for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&data, (unsigned char)keyword[i]);
+  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
+  ucvector_push_back(&data, 0); /*null termination char*/
+  ucvector_push_back(&data, compressed ? 1 : 0); /*compression flag*/
+  ucvector_push_back(&data, 0); /*compression method*/
+  for(i = 0; langtag[i] != 0; i++) ucvector_push_back(&data, (unsigned char)langtag[i]);
+  ucvector_push_back(&data, 0); /*null termination char*/
+  for(i = 0; transkey[i] != 0; i++) ucvector_push_back(&data, (unsigned char)transkey[i]);
+  ucvector_push_back(&data, 0); /*null termination char*/
+
+  if(compressed)
+  {
+    ucvector compressed_data;
+    ucvector_init(&compressed_data);
+    error = zlib_compress(&compressed_data.data, &compressed_data.size,
+                          (unsigned char*)textstring, textsize, zlibsettings);
+    if(!error)
+    {
+      for(i = 0; i < compressed_data.size; i++) ucvector_push_back(&data, compressed_data.data[i]);
+    }
+    ucvector_cleanup(&compressed_data);
+  }
+  else /*not compressed*/
+  {
+    for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&data, (unsigned char)textstring[i]);
+  }
+
+  if(!error) error = addChunk(out, "iTXt", data.data, data.size);
+  ucvector_cleanup(&data);
+  return error;
+}
+
+static unsigned addChunk_bKGD(ucvector* out, const LodePNGInfo* info)
+{
+  unsigned error = 0;
+  ucvector bKGD;
+  ucvector_init(&bKGD);
+  if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
+  {
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
+  }
+  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
+  {
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_g / 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_g % 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_b / 256));
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_b % 256));
+  }
+  else if(info->color.colortype == LCT_PALETTE)
+  {
+    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256)); /*palette index*/
+  }
+
+  error = addChunk(out, "bKGD", bKGD.data, bKGD.size);
+  ucvector_cleanup(&bKGD);
+
+  return error;
+}
+
+static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
+{
+  unsigned error = 0;
+  unsigned char* data = (unsigned char*)mymalloc(7);
+  if(!data) return 83; /*alloc fail*/
+  data[0] = (unsigned char)(time->year / 256);
+  data[1] = (unsigned char)(time->year % 256);
+  data[2] = time->month;
+  data[3] = time->day;
+  data[4] = time->hour;
+  data[5] = time->minute;
+  data[6] = time->second;
+  error = addChunk(out, "tIME", data, 7);
+  myfree(data);
+  return error;
+}
+
+static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* info)
+{
+  unsigned error = 0;
+  ucvector data;
+  ucvector_init(&data);
+
+  lodepng_add32bitInt(&data, info->phys_x);
+  lodepng_add32bitInt(&data, info->phys_y);
+  ucvector_push_back(&data, info->phys_unit);
+
+  error = addChunk(out, "pHYs", data.data, data.size);
+  ucvector_cleanup(&data);
+
+  return error;
+}
+
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+static void filterScanline(unsigned char* out, const unsigned char* scanline, const unsigned char* prevline,
+                           size_t length, size_t bytewidth, unsigned char filterType)
+{
+  size_t i;
+  switch(filterType)
+  {
+    case 0: /*None*/
+      for(i = 0; i < length; i++) out[i] = scanline[i];
+      break;
+    case 1: /*Sub*/
+      if(prevline)
+      {
+        for(i = 0; i < bytewidth; i++) out[i] = scanline[i];
+        for(i = bytewidth; i < length; i++) out[i] = scanline[i] - scanline[i - bytewidth];
+      }
+      else
+      {
+        for(i = 0; i < bytewidth; i++) out[i] = scanline[i];
+        for(i = bytewidth; i < length; i++) out[i] = scanline[i] - scanline[i - bytewidth];
+      }
+      break;
+    case 2: /*Up*/
+      if(prevline)
+      {
+        for(i = 0; i < length; i++) out[i] = scanline[i] - prevline[i];
+      }
+      else
+      {
+        for(i = 0; i < length; i++) out[i] = scanline[i];
+      }
+      break;
+    case 3: /*Average*/
+      if(prevline)
+      {
+        for(i = 0; i < bytewidth; i++) out[i] = scanline[i] - prevline[i] / 2;
+        for(i = bytewidth; i < length; i++) out[i] = scanline[i] - ((scanline[i - bytewidth] + prevline[i]) / 2);
+      }
+      else
+      {
+        for(i = 0; i < bytewidth; i++) out[i] = scanline[i];
+        for(i = bytewidth; i < length; i++) out[i] = scanline[i] - scanline[i - bytewidth] / 2;
+      }
+      break;
+    case 4: /*Paeth*/
+      if(prevline)
+      {
+        /*paethPredictor(0, prevline[i], 0) is always prevline[i]*/
+        for(i = 0; i < bytewidth; i++) out[i] = (scanline[i] - prevline[i]);
+        for(i = bytewidth; i < length; i++)
+        {
+          out[i] = (scanline[i] - paethPredictor(scanline[i - bytewidth], prevline[i], prevline[i - bytewidth]));
+        }
+      }
+      else
+      {
+        for(i = 0; i < bytewidth; i++) out[i] = scanline[i];
+        /*paethPredictor(scanline[i - bytewidth], 0, 0) is always scanline[i - bytewidth]*/
+        for(i = bytewidth; i < length; i++) out[i] = (scanline[i] - scanline[i - bytewidth]);
+      }
+      break;
+    default: return; /*unexisting filter type given*/
+  }
+}
+
+/* log2 approximation. A slight bit faster than std::log. */
+static float flog2(float f)
+{
+  float result = 0;
+  while(f > 32) { result += 4; f /= 16; }
+  while(f > 2) { result++; f /= 2; }
+  return result + 1.442695f * (f * f * f / 3 - 3 * f * f / 2 + 3 * f - 1.83333f);
+}
+
+static unsigned filter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h,
+                       const LodePNGColorMode* info, const LodePNGEncoderSettings* settings)
+{
+  /*
+  For PNG filter method 0
+  out must be a buffer with as size: h + (w * h * bpp + 7) / 8, because there are
+  the scanlines with 1 extra byte per scanline
+  */
+
+  unsigned bpp = lodepng_get_bpp(info);
+  /*the width of a scanline in bytes, not including the filter type*/
+  size_t linebytes = (w * bpp + 7) / 8;
+  /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
+  size_t bytewidth = (bpp + 7) / 8;
+  const unsigned char* prevline = 0;
+  unsigned x, y;
+  unsigned error = 0;
+  LodePNGFilterStrategy strategy = settings->filter_strategy;
+
+  /*
+  There is a heuristic called the minimum sum of absolute differences heuristic, suggested by the PNG standard:
+   *  If the image type is Palette, or the bit depth is smaller than 8, then do not filter the image (i.e.
+      use fixed filtering, with the filter None).
+   * (The other case) If the image type is Grayscale or RGB (with or without Alpha), and the bit depth is
+     not smaller than 8, then use adaptive filtering heuristic as follows: independently for each row, apply
+     all five filters and select the filter that produces the smallest sum of absolute values per row.
+  This heuristic is used if filter strategy is LFS_MINSUM and filter_palette_zero is true.
+
+  If filter_palette_zero is true and filter_strategy is not LFS_MINSUM, the above heuristic is followed,
+  but for "the other case", whatever strategy filter_strategy is set to instead of the minimum sum
+  heuristic is used.
+  */
+  if(settings->filter_palette_zero &&
+     (info->colortype == LCT_PALETTE || info->bitdepth < 8)) strategy = LFS_ZERO;
+
+  if(bpp == 0) return 31; /*error: invalid color type*/
+
+  if(strategy == LFS_ZERO)
+  {
+    for(y = 0; y < h; y++)
+    {
+      size_t outindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
+      size_t inindex = linebytes * y;
+      out[outindex] = 0; /*filter type byte*/
+      filterScanline(&out[outindex + 1], &in[inindex], prevline, linebytes, bytewidth, 0);
+      prevline = &in[inindex];
+    }
+  }
+  else if(strategy == LFS_MINSUM)
+  {
+    /*adaptive filtering*/
+    size_t sum[5];
+    ucvector attempt[5]; /*five filtering attempts, one for each filter type*/
+    size_t smallest = 0;
+    unsigned type, bestType = 0;
+
+    for(type = 0; type < 5; type++)
+    {
+      ucvector_init(&attempt[type]);
+      if(!ucvector_resize(&attempt[type], linebytes)) return 83; /*alloc fail*/
+    }
+
+    if(!error)
+    {
+      for(y = 0; y < h; y++)
+      {
+        /*try the 5 filter types*/
+        for(type = 0; type < 5; type++)
+        {
+          filterScanline(attempt[type].data, &in[y * linebytes], prevline, linebytes, bytewidth, type);
+
+          /*calculate the sum of the result*/
+          sum[type] = 0;
+          if(type == 0)
+          {
+            for(x = 0; x < linebytes; x++) sum[type] += (unsigned char)(attempt[type].data[x]);
+          }
+          else
+          {
+            for(x = 0; x < linebytes; x++)
+            {
+              /*For differences, each byte should be treated as signed, values above 127 are negative
+              (converted to signed char). Filtertype 0 isn't a difference though, so use unsigned there.
+              This means filtertype 0 is almost never chosen, but that is justified.*/
+              signed char s = (signed char)(attempt[type].data[x]);
+              sum[type] += s < 0 ? -s : s;
+            }
+          }
+
+          /*check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/
+          if(type == 0 || sum[type] < smallest)
+          {
+            bestType = type;
+            smallest = sum[type];
+          }
+        }
+
+        prevline = &in[y * linebytes];
+
+        /*now fill the out values*/
+        out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/
+        for(x = 0; x < linebytes; x++) out[y * (linebytes + 1) + 1 + x] = attempt[bestType].data[x];
+      }
+    }
+
+    for(type = 0; type < 5; type++) ucvector_cleanup(&attempt[type]);
+  }
+  else if(strategy == LFS_ENTROPY)
+  {
+    float sum[5];
+    ucvector attempt[5]; /*five filtering attempts, one for each filter type*/
+    float smallest = 0;
+    unsigned type, bestType = 0;
+    unsigned count[256];
+
+    for(type = 0; type < 5; type++)
+    {
+      ucvector_init(&attempt[type]);
+      if(!ucvector_resize(&attempt[type], linebytes)) return 83; /*alloc fail*/
+    }
+
+    for(y = 0; y < h; y++)
+    {
+      /*try the 5 filter types*/
+      for(type = 0; type < 5; type++)
+      {
+        filterScanline(attempt[type].data, &in[y * linebytes], prevline, linebytes, bytewidth, type);
+        for(x = 0; x < 256; x++) count[x] = 0;
+        for(x = 0; x < linebytes; x++) count[attempt[type].data[x]]++;
+        count[type]++; /*the filter type itself is part of the scanline*/
+        sum[type] = 0;
+        for(x = 0; x < 256; x++)
+        {
+          float p = count[x] / (float)(linebytes + 1);
+          sum[type] += count[x] == 0 ? 0 : flog2(1 / p) * p;
+        }
+        /*check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/
+        if(type == 0 || sum[type] < smallest)
+        {
+          bestType = type;
+          smallest = sum[type];
+        }
+      }
+
+      prevline = &in[y * linebytes];
+
+      /*now fill the out values*/
+      out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/
+      for(x = 0; x < linebytes; x++) out[y * (linebytes + 1) + 1 + x] = attempt[bestType].data[x];
+    }
+
+    for(type = 0; type < 5; type++) ucvector_cleanup(&attempt[type]);
+  }
+  else if(strategy == LFS_PREDEFINED)
+  {
+    for(y = 0; y < h; y++)
+    {
+      size_t outindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
+      size_t inindex = linebytes * y;
+      unsigned type = settings->predefined_filters[y];
+      out[outindex] = type; /*filter type byte*/
+      filterScanline(&out[outindex + 1], &in[inindex], prevline, linebytes, bytewidth, type);
+      prevline = &in[inindex];
+    }
+  }
+  else if(strategy == LFS_BRUTE_FORCE)
+  {
+    /*brute force filter chooser.
+    deflate the scanline after every filter attempt to see which one deflates best.
+    This is very slow and gives only slightly smaller, sometimes even larger, result*/
+    size_t size[5];
+    ucvector attempt[5]; /*five filtering attempts, one for each filter type*/
+    size_t smallest = 0;
+    unsigned type = 0, bestType = 0;
+    unsigned char* dummy;
+    LodePNGCompressSettings zlibsettings = settings->zlibsettings;
+    /*use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose,
+    to simulate the true case where the tree is the same for the whole image. Sometimes it gives
+    better result with dynamic tree anyway. Using the fixed tree sometimes gives worse, but in rare
+    cases better compression. It does make this a bit less slow, so it's worth doing this.*/
+    zlibsettings.btype = 1;
+    /*a custom encoder likely doesn't read the btype setting and is optimized for complete PNG
+    images only, so disable it*/
+    zlibsettings.custom_zlib = 0;
+    zlibsettings.custom_deflate = 0;
+    for(type = 0; type < 5; type++)
+    {
+      ucvector_init(&attempt[type]);
+      ucvector_resize(&attempt[type], linebytes); /*todo: give error if resize failed*/
+    }
+    for(y = 0; y < h; y++) /*try the 5 filter types*/
+    {
+      for(type = 0; type < 5; type++)
+      {
+        unsigned testsize = attempt[type].size;
+        /*if(testsize > 8) testsize /= 8;*/ /*it already works good enough by testing a part of the row*/
+
+        filterScanline(attempt[type].data, &in[y * linebytes], prevline, linebytes, bytewidth, type);
+        size[type] = 0;
+        dummy = 0;
+        zlib_compress(&dummy, &size[type], attempt[type].data, testsize, &zlibsettings);
+        myfree(dummy);
+        /*check if this is smallest size (or if type == 0 it's the first case so always store the values)*/
+        if(type == 0 || size[type] < smallest)
+        {
+          bestType = type;
+          smallest = size[type];
+        }
+      }
+      prevline = &in[y * linebytes];
+      out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/
+      for(x = 0; x < linebytes; x++) out[y * (linebytes + 1) + 1 + x] = attempt[bestType].data[x];
+    }
+    for(type = 0; type < 5; type++) ucvector_cleanup(&attempt[type]);
+  }
+  else return 88; /* unknown filter strategy */
+
+  return error;
+}
+
+static void addPaddingBits(unsigned char* out, const unsigned char* in,
+                           size_t olinebits, size_t ilinebits, unsigned h)
+{
+  /*The opposite of the removePaddingBits function
+  olinebits must be >= ilinebits*/
+  unsigned y;
+  size_t diff = olinebits - ilinebits;
+  size_t obp = 0, ibp = 0; /*bit pointers*/
+  for(y = 0; y < h; y++)
+  {
+    size_t x;
+    for(x = 0; x < ilinebits; x++)
+    {
+      unsigned char bit = readBitFromReversedStream(&ibp, in);
+      setBitOfReversedStream(&obp, out, bit);
+    }
+    /*obp += diff; --> no, fill in some value in the padding bits too, to avoid
+    "Use of uninitialised value of size ###" warning from valgrind*/
+    for(x = 0; x < diff; x++) setBitOfReversedStream(&obp, out, 0);
+  }
+}
+
+/*
+in: non-interlaced image with size w*h
+out: the same pixels, but re-ordered according to PNG's Adam7 interlacing, with
+ no padding bits between scanlines, but between reduced images so that each
+ reduced image starts at a byte.
+bpp: bits per pixel
+there are no padding bits, not between scanlines, not between reduced images
+in has the following size in bits: w * h * bpp.
+out is possibly bigger due to padding bits between reduced images
+NOTE: comments about padding bits are only relevant if bpp < 8
+*/
+static void Adam7_interlace(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
+{
+  unsigned passw[7], passh[7];
+  size_t filter_passstart[8], padded_passstart[8], passstart[8];
+  unsigned i;
+
+  Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
+
+  if(bpp >= 8)
+  {
+    for(i = 0; i < 7; i++)
+    {
+      unsigned x, y, b;
+      size_t bytewidth = bpp / 8;
+      for(y = 0; y < passh[i]; y++)
+      for(x = 0; x < passw[i]; x++)
+      {
+        size_t pixelinstart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * bytewidth;
+        size_t pixeloutstart = passstart[i] + (y * passw[i] + x) * bytewidth;
+        for(b = 0; b < bytewidth; b++)
+        {
+          out[pixeloutstart + b] = in[pixelinstart + b];
+        }
+      }
+    }
+  }
+  else /*bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers*/
+  {
+    for(i = 0; i < 7; i++)
+    {
+      unsigned x, y, b;
+      unsigned ilinebits = bpp * passw[i];
+      unsigned olinebits = bpp * w;
+      size_t obp, ibp; /*bit pointers (for out and in buffer)*/
+      for(y = 0; y < passh[i]; y++)
+      for(x = 0; x < passw[i]; x++)
+      {
+        ibp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp;
+        obp = (8 * passstart[i]) + (y * ilinebits + x * bpp);
+        for(b = 0; b < bpp; b++)
+        {
+          unsigned char bit = readBitFromReversedStream(&ibp, in);
+          setBitOfReversedStream(&obp, out, bit);
+        }
+      }
+    }
+  }
+}
+
+/*out must be buffer big enough to contain uncompressed IDAT chunk data, and in must contain the full image.
+return value is error**/
+static unsigned preProcessScanlines(unsigned char** out, size_t* outsize, const unsigned char* in,
+                                    unsigned w, unsigned h,
+                                    const LodePNGInfo* info_png, const LodePNGEncoderSettings* settings)
+{
+  /*
+  This function converts the pure 2D image with the PNG's colortype, into filtered-padded-interlaced data. Steps:
+  *) if no Adam7: 1) add padding bits (= posible extra bits per scanline if bpp < 8) 2) filter
+  *) if adam7: 1) Adam7_interlace 2) 7x add padding bits 3) 7x filter
+  */
+  unsigned bpp = lodepng_get_bpp(&info_png->color);
+  unsigned error = 0;
+
+  if(info_png->interlace_method == 0)
+  {
+    *outsize = h + (h * ((w * bpp + 7) / 8)); /*image size plus an extra byte per scanline + possible padding bits*/
+    *out = (unsigned char*)mymalloc(*outsize);
+    if(!(*out) && (*outsize)) error = 83; /*alloc fail*/
+
+    if(!error)
+    {
+      /*non multiple of 8 bits per scanline, padding bits needed per scanline*/
+      if(bpp < 8 && w * bpp != ((w * bpp + 7) / 8) * 8)
+      {
+        unsigned char* padded = (unsigned char*)mymalloc(h * ((w * bpp + 7) / 8));
+        if(!padded) error = 83; /*alloc fail*/
+        if(!error)
+        {
+          addPaddingBits(padded, in, ((w * bpp + 7) / 8) * 8, w * bpp, h);
+          error = filter(*out, padded, w, h, &info_png->color, settings);
+        }
+        myfree(padded);
+      }
+      else
+      {
+        /*we can immediatly filter into the out buffer, no other steps needed*/
+        error = filter(*out, in, w, h, &info_png->color, settings);
+      }
+    }
+  }
+  else /*interlace_method is 1 (Adam7)*/
+  {
+    unsigned passw[7], passh[7];
+    size_t filter_passstart[8], padded_passstart[8], passstart[8];
+    unsigned char* adam7;
+
+    Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp);
+
+    *outsize = filter_passstart[7]; /*image size plus an extra byte per scanline + possible padding bits*/
+    *out = (unsigned char*)mymalloc(*outsize);
+    if(!(*out)) error = 83; /*alloc fail*/
+
+    adam7 = (unsigned char*)mymalloc(passstart[7]);
+    if(!adam7 && passstart[7]) error = 83; /*alloc fail*/
+
+    if(!error)
+    {
+      unsigned i;
+
+      Adam7_interlace(adam7, in, w, h, bpp);
+      for(i = 0; i < 7; i++)
+      {
+        if(bpp < 8)
+        {
+          unsigned char* padded = (unsigned char*)mymalloc(padded_passstart[i + 1] - padded_passstart[i]);
+          if(!padded) ERROR_BREAK(83); /*alloc fail*/
+          addPaddingBits(padded, &adam7[passstart[i]],
+                         ((passw[i] * bpp + 7) / 8) * 8, passw[i] * bpp, passh[i]);
+          error = filter(&(*out)[filter_passstart[i]], padded,
+                         passw[i], passh[i], &info_png->color, settings);
+          myfree(padded);
+        }
+        else
+        {
+          error = filter(&(*out)[filter_passstart[i]], &adam7[padded_passstart[i]],
+                         passw[i], passh[i], &info_png->color, settings);
+        }
+
+        if(error) break;
+      }
+    }
+
+    myfree(adam7);
+  }
+
+  return error;
+}
+
+/*
+palette must have 4 * palettesize bytes allocated, and given in format RGBARGBARGBARGBA...
+returns 0 if the palette is opaque,
+returns 1 if the palette has a single color with alpha 0 ==> color key
+returns 2 if the palette is semi-translucent.
+*/
+static unsigned getPaletteTranslucency(const unsigned char* palette, size_t palettesize)
+{
+  size_t i, key = 0;
+  unsigned r = 0, g = 0, b = 0; /*the value of the color with alpha 0, so long as color keying is possible*/
+  for(i = 0; i < palettesize; i++)
+  {
+    if(!key && palette[4 * i + 3] == 0)
+    {
+      r = palette[4 * i + 0]; g = palette[4 * i + 1]; b = palette[4 * i + 2];
+      key = 1;
+      i = (size_t)(-1); /*restart from beginning, to detect earlier opaque colors with key's value*/
+    }
+    else if(palette[4 * i + 3] != 255) return 2;
+    /*when key, no opaque RGB may have key's RGB*/
+    else if(key && r == palette[i * 4 + 0] && g == palette[i * 4 + 1] && b == palette[i * 4 + 2]) return 2;
+  }
+  return key;
+}
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+static unsigned addUnknownChunks(ucvector* out, unsigned char* data, size_t datasize)
+{
+  unsigned char* inchunk = data;
+  while((size_t)(inchunk - data) < datasize)
+  {
+    CERROR_TRY_RETURN(lodepng_chunk_append(&out->data, &out->size, inchunk));
+    out->allocsize = out->size; /*fix the allocsize again*/
+    inchunk = lodepng_chunk_next(inchunk);
+  }
+  return 0;
+}
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+unsigned lodepng_encode(unsigned char** out, size_t* outsize,
+                        const unsigned char* image, unsigned w, unsigned h,
+                        LodePNGState* state)
+{
+  LodePNGInfo info;
+  ucvector outv;
+  unsigned char* data = 0; /*uncompressed version of the IDAT chunk data*/
+  size_t datasize = 0;
+
+  /*provide some proper output values if error will happen*/
+  *out = 0;
+  *outsize = 0;
+  state->error = 0;
+
+  lodepng_info_init(&info);
+  lodepng_info_copy(&info, &state->info_png);
+
+  if((info.color.colortype == LCT_PALETTE || state->encoder.force_palette)
+      && (info.color.palettesize == 0 || info.color.palettesize > 256))
+  {
+    state->error = 68; /*invalid palette size, it is only allowed to be 1-256*/
+    return state->error;
+  }
+
+  if(state->encoder.auto_convert != LAC_NO)
+  {
+    state->error = doAutoChooseColor(&info.color, image, w, h, &state->info_raw,
+                                     state->encoder.auto_convert);
+  }
+  if(state->error) return state->error;
+
+  if(state->encoder.zlibsettings.windowsize > 32768)
+  {
+    CERROR_RETURN_ERROR(state->error, 60); /*error: windowsize larger than allowed*/
+  }
+  if(state->encoder.zlibsettings.btype > 2)
+  {
+    CERROR_RETURN_ERROR(state->error, 61); /*error: unexisting btype*/
+  }
+  if(state->info_png.interlace_method > 1)
+  {
+    CERROR_RETURN_ERROR(state->error, 71); /*error: unexisting interlace mode*/
+  }
+
+  state->error = checkColorValidity(info.color.colortype, info.color.bitdepth);
+  if(state->error) return state->error; /*error: unexisting color type given*/
+  state->error = checkColorValidity(state->info_raw.colortype, state->info_raw.bitdepth);
+  if(state->error) return state->error; /*error: unexisting color type given*/
+
+  if(!lodepng_color_mode_equal(&state->info_raw, &info.color))
+  {
+    unsigned char* converted;
+    size_t size = (w * h * lodepng_get_bpp(&info.color) + 7) / 8;
+
+    converted = (unsigned char*)mymalloc(size);
+    if(!converted && size) state->error = 83; /*alloc fail*/
+    if(!state->error)
+    {
+      state->error = lodepng_convert(converted, image, &info.color, &state->info_raw, w, h);
+    }
+    if(!state->error) preProcessScanlines(&data, &datasize, converted, w, h, &info, &state->encoder);
+    myfree(converted);
+  }
+  else preProcessScanlines(&data, &datasize, image, w, h, &info, &state->encoder);
+
+  ucvector_init(&outv);
+  while(!state->error) /*while only executed once, to break on error*/
+  {
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+    size_t i;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    /*write signature and chunks*/
+    writeSignature(&outv);
+    /*IHDR*/
+    addChunk_IHDR(&outv, w, h, info.color.colortype, info.color.bitdepth, info.interlace_method);
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+    /*unknown chunks between IHDR and PLTE*/
+    if(info.unknown_chunks_data[0])
+    {
+      state->error = addUnknownChunks(&outv, info.unknown_chunks_data[0], info.unknown_chunks_size[0]);
+      if(state->error) break;
+    }
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    /*PLTE*/
+    if(info.color.colortype == LCT_PALETTE)
+    {
+      addChunk_PLTE(&outv, &info.color);
+    }
+    if(state->encoder.force_palette && (info.color.colortype == LCT_RGB || info.color.colortype == LCT_RGBA))
+    {
+      addChunk_PLTE(&outv, &info.color);
+    }
+    /*tRNS*/
+    if(info.color.colortype == LCT_PALETTE && getPaletteTranslucency(info.color.palette, info.color.palettesize) != 0)
+    {
+      addChunk_tRNS(&outv, &info.color);
+    }
+    if((info.color.colortype == LCT_GREY || info.color.colortype == LCT_RGB) && info.color.key_defined)
+    {
+      addChunk_tRNS(&outv, &info.color);
+    }
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+    /*bKGD (must come between PLTE and the IDAt chunks*/
+    if(info.background_defined) addChunk_bKGD(&outv, &info);
+    /*pHYs (must come before the IDAT chunks)*/
+    if(info.phys_defined) addChunk_pHYs(&outv, &info);
+
+    /*unknown chunks between PLTE and IDAT*/
+    if(info.unknown_chunks_data[1])
+    {
+      state->error = addUnknownChunks(&outv, info.unknown_chunks_data[1], info.unknown_chunks_size[1]);
+      if(state->error) break;
+    }
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    /*IDAT (multiple IDAT chunks must be consecutive)*/
+    state->error = addChunk_IDAT(&outv, data, datasize, &state->encoder.zlibsettings);
+    if(state->error) break;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+    /*tIME*/
+    if(info.time_defined) addChunk_tIME(&outv, &info.time);
+    /*tEXt and/or zTXt*/
+    for(i = 0; i < info.text_num; i++)
+    {
+      if(strlen(info.text_keys[i]) > 79)
+      {
+        state->error = 66; /*text chunk too large*/
+        break;
+      }
+      if(strlen(info.text_keys[i]) < 1)
+      {
+        state->error = 67; /*text chunk too small*/
+        break;
+      }
+      if(state->encoder.text_compression)
+        addChunk_zTXt(&outv, info.text_keys[i], info.text_strings[i], &state->encoder.zlibsettings);
+      else
+        addChunk_tEXt(&outv, info.text_keys[i], info.text_strings[i]);
+    }
+    /*LodePNG version id in text chunk*/
+    if(state->encoder.add_id)
+    {
+      unsigned alread_added_id_text = 0;
+      for(i = 0; i < info.text_num; i++)
+      {
+        if(!strcmp(info.text_keys[i], "LodePNG"))
+        {
+          alread_added_id_text = 1;
+          break;
+        }
+      }
+      if(alread_added_id_text == 0)
+        addChunk_tEXt(&outv, "LodePNG", VERSION_STRING); /*it's shorter as tEXt than as zTXt chunk*/
+    }
+    /*iTXt*/
+    for(i = 0; i < info.itext_num; i++)
+    {
+      if(strlen(info.itext_keys[i]) > 79)
+      {
+        state->error = 66; /*text chunk too large*/
+        break;
+      }
+      if(strlen(info.itext_keys[i]) < 1)
+      {
+        state->error = 67; /*text chunk too small*/
+        break;
+      }
+      addChunk_iTXt(&outv, state->encoder.text_compression,
+                    info.itext_keys[i], info.itext_langtags[i], info.itext_transkeys[i], info.itext_strings[i],
+                    &state->encoder.zlibsettings);
+    }
+
+    /*unknown chunks between IDAT and IEND*/
+    if(info.unknown_chunks_data[2])
+    {
+      state->error = addUnknownChunks(&outv, info.unknown_chunks_data[2], info.unknown_chunks_size[2]);
+      if(state->error) break;
+    }
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+    /*IEND*/
+    addChunk_IEND(&outv);
+
+    break; /*this isn't really a while loop; no error happened so break out now!*/
+  }
+
+  lodepng_info_cleanup(&info);
+  myfree(data);
+  /*instead of cleaning the vector up, give it to the output*/
+  *out = outv.data;
+  *outsize = outv.size;
+
+  return state->error;
+}
+
+unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize, const unsigned char* image,
+                               unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned error;
+  LodePNGState state;
+  lodepng_state_init(&state);
+  state.info_raw.colortype = colortype;
+  state.info_raw.bitdepth = bitdepth;
+  state.info_png.color.colortype = colortype;
+  state.info_png.color.bitdepth = bitdepth;
+  lodepng_encode(out, outsize, image, w, h, &state);
+  error = state.error;
+  lodepng_state_cleanup(&state);
+  return error;
+}
+
+unsigned lodepng_encode32(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h)
+{
+  return lodepng_encode_memory(out, outsize, image, w, h, LCT_RGBA, 8);
+}
+
+unsigned lodepng_encode24(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h)
+{
+  return lodepng_encode_memory(out, outsize, image, w, h, LCT_RGB, 8);
+}
+
+#ifdef LODEPNG_COMPILE_DISK
+unsigned lodepng_encode_file(const char* filename, const unsigned char* image, unsigned w, unsigned h,
+                             LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned char* buffer;
+  size_t buffersize;
+  unsigned error = lodepng_encode_memory(&buffer, &buffersize, image, w, h, colortype, bitdepth);
+  if(!error) error = lodepng_save_file(buffer, buffersize, filename);
+  myfree(buffer);
+  return error;
+}
+
+unsigned lodepng_encode32_file(const char* filename, const unsigned char* image, unsigned w, unsigned h)
+{
+  return lodepng_encode_file(filename, image, w, h, LCT_RGBA, 8);
+}
+
+unsigned lodepng_encode24_file(const char* filename, const unsigned char* image, unsigned w, unsigned h)
+{
+  return lodepng_encode_file(filename, image, w, h, LCT_RGB, 8);
+}
+#endif /*LODEPNG_COMPILE_DISK*/
+
+void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings)
+{
+  lodepng_compress_settings_init(&settings->zlibsettings);
+  settings->filter_palette_zero = 1;
+  settings->filter_strategy = LFS_MINSUM;
+  settings->auto_convert = LAC_AUTO;
+  settings->force_palette = 0;
+  settings->predefined_filters = 0;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  settings->add_id = 0;
+  settings->text_compression = 1;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+}
+
+#endif /*LODEPNG_COMPILE_ENCODER*/
+#endif /*LODEPNG_COMPILE_PNG*/
+
+#ifdef LODEPNG_COMPILE_ERROR_TEXT
+/*
+This returns the description of a numerical error code in English. This is also
+the documentation of all the error codes.
+*/
+const char* lodepng_error_text(unsigned code)
+{
+  switch(code)
+  {
+    case 0: return "no error, everything went ok";
+    case 1: return "nothing done yet"; /*the Encoder/Decoder has done nothing yet, error checking makes no sense yet*/
+    case 10: return "end of input memory reached without huffman end code"; /*while huffman decoding*/
+    case 11: return "error in code tree made it jump outside of huffman tree"; /*while huffman decoding*/
+    case 13: return "problem while processing dynamic deflate block";
+    case 14: return "problem while processing dynamic deflate block";
+    case 15: return "problem while processing dynamic deflate block";
+    case 16: return "unexisting code while processing dynamic deflate block";
+    case 17: return "end of out buffer memory reached while inflating";
+    case 18: return "invalid distance code while inflating";
+    case 19: return "end of out buffer memory reached while inflating";
+    case 20: return "invalid deflate block BTYPE encountered while decoding";
+    case 21: return "NLEN is not ones complement of LEN in a deflate block";
+     /*end of out buffer memory reached while inflating:
+     This can happen if the inflated deflate data is longer than the amount of bytes required to fill up
+     all the pixels of the image, given the color depth and image dimensions. Something that doesn't
+     happen in a normal, well encoded, PNG image.*/
+    case 22: return "end of out buffer memory reached while inflating";
+    case 23: return "end of in buffer memory reached while inflating";
+    case 24: return "invalid FCHECK in zlib header";
+    case 25: return "invalid compression method in zlib header";
+    case 26: return "FDICT encountered in zlib header while it's not used for PNG";
+    case 27: return "PNG file is smaller than a PNG header";
+    /*Checks the magic file header, the first 8 bytes of the PNG file*/
+    case 28: return "incorrect PNG signature, it's no PNG or corrupted";
+    case 29: return "first chunk is not the header chunk";
+    case 30: return "chunk length too large, chunk broken off at end of file";
+    case 31: return "illegal PNG color type or bpp";
+    case 32: return "illegal PNG compression method";
+    case 33: return "illegal PNG filter method";
+    case 34: return "illegal PNG interlace method";
+    case 35: return "chunk length of a chunk is too large or the chunk too small";
+    case 36: return "illegal PNG filter type encountered";
+    case 37: return "illegal bit depth for this color type given";
+    case 38: return "the palette is too big"; /*more than 256 colors*/
+    case 39: return "more palette alpha values given in tRNS chunk than there are colors in the palette";
+    case 40: return "tRNS chunk has wrong size for greyscale image";
+    case 41: return "tRNS chunk has wrong size for RGB image";
+    case 42: return "tRNS chunk appeared while it was not allowed for this color type";
+    case 43: return "bKGD chunk has wrong size for palette image";
+    case 44: return "bKGD chunk has wrong size for greyscale image";
+    case 45: return "bKGD chunk has wrong size for RGB image";
+    /*Is the palette too small?*/
+    case 46: return "a value in indexed image is larger than the palette size (bitdepth = 8)";
+    /*Is the palette too small?*/
+    case 47: return "a value in indexed image is larger than the palette size (bitdepth < 8)";
+    /*the input data is empty, maybe a PNG file doesn't exist or is in the wrong path*/
+    case 48: return "empty input or file doesn't exist";
+    case 49: return "jumped past memory while generating dynamic huffman tree";
+    case 50: return "jumped past memory while generating dynamic huffman tree";
+    case 51: return "jumped past memory while inflating huffman block";
+    case 52: return "jumped past memory while inflating";
+    case 53: return "size of zlib data too small";
+    case 54: return "repeat symbol in tree while there was no value symbol yet";
+    /*jumped past tree while generating huffman tree, this could be when the
+    tree will have more leaves than symbols after generating it out of the
+    given lenghts. They call this an oversubscribed dynamic bit lengths tree in zlib.*/
+    case 55: return "jumped past tree while generating huffman tree";
+    case 56: return "given output image colortype or bitdepth not supported for color conversion";
+    case 57: return "invalid CRC encountered (checking CRC can be disabled)";
+    case 58: return "invalid ADLER32 encountered (checking ADLER32 can be disabled)";
+    case 59: return "requested color conversion not supported";
+    case 60: return "invalid window size given in the settings of the encoder (must be 0-32768)";
+    case 61: return "invalid BTYPE given in the settings of the encoder (only 0, 1 and 2 are allowed)";
+    /*LodePNG leaves the choice of RGB to greyscale conversion formula to the user.*/
+    case 62: return "conversion from color to greyscale not supported";
+    case 63: return "length of a chunk too long, max allowed for PNG is 2147483647 bytes per chunk"; /*(2^31-1)*/
+    /*this would result in the inability of a deflated block to ever contain an end code. It must be at least 1.*/
+    case 64: return "the length of the END symbol 256 in the Huffman tree is 0";
+    case 66: return "the length of a text chunk keyword given to the encoder is longer than the maximum of 79 bytes";
+    case 67: return "the length of a text chunk keyword given to the encoder is smaller than the minimum of 1 byte";
+    case 68: return "tried to encode a PLTE chunk with a palette that has less than 1 or more than 256 colors";
+    case 69: return "unknown chunk type with 'critical' flag encountered by the decoder";
+    case 71: return "unexisting interlace mode given to encoder (must be 0 or 1)";
+    case 72: return "while decoding, unexisting compression method encountering in zTXt or iTXt chunk (it must be 0)";
+    case 73: return "invalid tIME chunk size";
+    case 74: return "invalid pHYs chunk size";
+    /*length could be wrong, or data chopped off*/
+    case 75: return "no null termination char found while decoding text chunk";
+    case 76: return "iTXt chunk too short to contain required bytes";
+    case 77: return "integer overflow in buffer size";
+    case 78: return "failed to open file for reading"; /*file doesn't exist or couldn't be opened for reading*/
+    case 79: return "failed to open file for writing";
+    case 80: return "tried creating a tree of 0 symbols";
+    case 81: return "lazy matching at pos 0 is impossible";
+    case 82: return "color conversion to palette requested while a color isn't in palette";
+    case 83: return "memory allocation failed";
+    case 84: return "given image too small to contain all pixels to be encoded";
+    case 85: return "internal color conversion bug";
+    case 86: return "impossible offset in lz77 encoding (internal bug)";
+    case 87: return "must provide custom zlib function pointer if LODEPNG_COMPILE_ZLIB is not defined";
+    case 88: return "invalid filter strategy given for LodePNGEncoderSettings.filter_strategy";
+    case 89: return "text chunk keyword too short or long: must have size 1-79";
+  }
+  return "unknown error code";
+}
+#endif /*LODEPNG_COMPILE_ERROR_TEXT*/
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* // C++ Wrapper                                                          // */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+
+#ifdef LODEPNG_COMPILE_CPP
+namespace lodepng
+{
+
+#ifdef LODEPNG_COMPILE_DISK
+void load_file(std::vector<unsigned char>& buffer, const std::string& filename)
+{
+  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);
+
+  /*get filesize*/
+  std::streamsize size = 0;
+  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
+  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();
+
+  /*read contents of the file into the vector*/
+  buffer.resize(size_t(size));
+  if(size > 0) file.read((char*)(&buffer[0]), size);
+}
+
+/*write given buffer to the file, overwriting the file, it doesn't append to it.*/
+void save_file(const std::vector<unsigned char>& buffer, const std::string& filename)
+{
+  std::ofstream file(filename.c_str(), std::ios::out|std::ios::binary);
+  file.write(buffer.empty() ? 0 : (char*)&buffer[0], std::streamsize(buffer.size()));
+}
+#endif //LODEPNG_COMPILE_DISK
+
+#ifdef LODEPNG_COMPILE_ZLIB
+#ifdef LODEPNG_COMPILE_DECODER
+unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+                    const LodePNGDecompressSettings& settings)
+{
+  unsigned char* buffer = 0;
+  size_t buffersize = 0;
+  unsigned error = zlib_decompress(&buffer, &buffersize, in, insize, &settings);
+  if(buffer)
+  {
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+                    const LodePNGDecompressSettings& settings)
+{
+  return decompress(out, in.empty() ? 0 : &in[0], in.size(), settings);
+}
+#endif //LODEPNG_COMPILE_DECODER
+
+#ifdef LODEPNG_COMPILE_ENCODER
+unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+                  const LodePNGCompressSettings& settings)
+{
+  unsigned char* buffer = 0;
+  size_t buffersize = 0;
+  unsigned error = zlib_compress(&buffer, &buffersize, in, insize, &settings);
+  if(buffer)
+  {
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned compress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+                  const LodePNGCompressSettings& settings)
+{
+  return compress(out, in.empty() ? 0 : &in[0], in.size(), settings);
+}
+#endif //LODEPNG_COMPILE_ENCODER
+#endif //LODEPNG_COMPILE_ZLIB
+
+
+#ifdef LODEPNG_COMPILE_PNG
+
+State::State()
+{
+  lodepng_state_init(this);
+}
+
+State::State(const State& other)
+{
+  lodepng_state_init(this);
+  lodepng_state_copy(this, &other);
+}
+
+State::~State()
+{
+  lodepng_state_cleanup(this);
+}
+
+State& State::operator=(const State& other)
+{
+  lodepng_state_copy(this, &other);
+  return *this;
+}
+
+#ifdef LODEPNG_COMPILE_DECODER
+
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const unsigned char* in,
+                size_t insize, LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned char* buffer;
+  unsigned error = lodepng_decode_memory(&buffer, &w, &h, in, insize, colortype, bitdepth);
+  if(buffer && !error)
+  {
+    State state;
+    state.info_raw.colortype = colortype;
+    state.info_raw.bitdepth = bitdepth;
+    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                const std::vector<unsigned char>& in, LodePNGColorType colortype, unsigned bitdepth)
+{
+  return decode(out, w, h, in.empty() ? 0 : &in[0], (unsigned)in.size(), colortype, bitdepth);
+}
+
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                State& state,
+                const unsigned char* in, size_t insize)
+{
+  unsigned char* buffer;
+  unsigned error = lodepng_decode(&buffer, &w, &h, &state, in, insize);
+  if(buffer && !error)
+  {
+    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                State& state,
+                const std::vector<unsigned char>& in)
+{
+  return decode(out, w, h, state, in.empty() ? 0 : &in[0], in.size());
+}
+
+#ifdef LODEPNG_COMPILE_DISK
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::string& filename,
+                LodePNGColorType colortype, unsigned bitdepth)
+{
+  std::vector<unsigned char> buffer;
+  load_file(buffer, filename);
+  return decode(out, w, h, buffer, colortype, bitdepth);
+}
+#endif //LODEPNG_COMPILE_DECODER
+#endif //LODEPNG_COMPILE_DISK
+
+#ifdef LODEPNG_COMPILE_ENCODER
+unsigned encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h,
+                LodePNGColorType colortype, unsigned bitdepth)
+{
+  unsigned char* buffer;
+  size_t buffersize;
+  unsigned error = lodepng_encode_memory(&buffer, &buffersize, in, w, h, colortype, bitdepth);
+  if(buffer)
+  {
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned encode(std::vector<unsigned char>& out,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                LodePNGColorType colortype, unsigned bitdepth)
+{
+  if(lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size()) return 84;
+  return encode(out, in.empty() ? 0 : &in[0], w, h, colortype, bitdepth);
+}
+
+unsigned encode(std::vector<unsigned char>& out,
+                const unsigned char* in, unsigned w, unsigned h,
+                State& state)
+{
+  unsigned char* buffer;
+  size_t buffersize;
+  unsigned error = lodepng_encode(&buffer, &buffersize, in, w, h, &state);
+  if(buffer)
+  {
+    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
+    myfree(buffer);
+  }
+  return error;
+}
+
+unsigned encode(std::vector<unsigned char>& out,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                State& state)
+{
+  if(lodepng_get_raw_size(w, h, &state.info_raw) > in.size()) return 84;
+  return encode(out, in.empty() ? 0 : &in[0], w, h, state);
+}
+
+#ifdef LODEPNG_COMPILE_DISK
+unsigned encode(const std::string& filename,
+                const unsigned char* in, unsigned w, unsigned h,
+                LodePNGColorType colortype, unsigned bitdepth)
+{
+  std::vector<unsigned char> buffer;
+  unsigned error = encode(buffer, in, w, h, colortype, bitdepth);
+  if(!error) save_file(buffer, filename);
+  return error;
+}
+
+unsigned encode(const std::string& filename,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                LodePNGColorType colortype, unsigned bitdepth)
+{
+  if(lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size()) return 84;
+  return encode(filename, in.empty() ? 0 : &in[0], w, h, colortype, bitdepth);
+}
+#endif //LODEPNG_COMPILE_DISK
+#endif //LODEPNG_COMPILE_ENCODER
+#endif //LODEPNG_COMPILE_PNG
+} //namespace lodepng
+#endif /*LODEPNG_COMPILE_CPP*/
diff --git a/src/lodepng.h b/src/lodepng.h
new file mode 100644
index 0000000..6057acc
--- /dev/null
+++ b/src/lodepng.h
@@ -0,0 +1,1681 @@
+/*
+LodePNG version 20130128
+
+Copyright (c) 2005-2013 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+#ifndef LODEPNG_H
+#define LODEPNG_H
+
+#include <string.h> /*for size_t*/
+
+#ifdef __cplusplus
+#include <vector>
+#include <string>
+#endif /*__cplusplus*/
+
+/*
+The following #defines are used to create code sections. They can be disabled
+to disable code sections, which can give faster compile time and smaller binary.
+The "NO_COMPILE" defines are designed to be used to pass as defines to the
+compiler command to disable them without modifying this header, e.g.
+-DLODEPNG_NO_COMPILE_ZLIB for gcc.
+*/
+/*deflate & zlib. If disabled, you must specify alternative zlib functions in
+the custom_zlib field of the compress and decompress settings*/
+#ifndef LODEPNG_NO_COMPILE_ZLIB
+#define LODEPNG_COMPILE_ZLIB
+#endif
+/*png encoder and png decoder*/
+#ifndef LODEPNG_NO_COMPILE_PNG
+#define LODEPNG_COMPILE_PNG
+#endif
+/*deflate&zlib decoder and png decoder*/
+#ifndef LODEPNG_NO_COMPILE_DECODER
+#define LODEPNG_COMPILE_DECODER
+#endif
+/*deflate&zlib encoder and png encoder*/
+#ifndef LODEPNG_NO_COMPILE_ENCODER
+#define LODEPNG_COMPILE_ENCODER
+#endif
+/*the optional built in harddisk file loading and saving functions*/
+#ifndef LODEPNG_NO_COMPILE_DISK
+#define LODEPNG_COMPILE_DISK
+#endif
+/*support for chunks other than IHDR, IDAT, PLTE, tRNS, IEND: ancillary and unknown chunks*/
+#ifndef LODEPNG_NO_COMPILE_ANCILLARY_CHUNKS
+#define LODEPNG_COMPILE_ANCILLARY_CHUNKS
+#endif
+/*ability to convert error numerical codes to English text string*/
+#ifndef LODEPNG_NO_COMPILE_ERROR_TEXT
+#define LODEPNG_COMPILE_ERROR_TEXT
+#endif
+/*compile the C++ version (you can disable the C++ wrapper here even when compiling for C++)*/
+#ifdef __cplusplus
+#ifndef LODEPNG_NO_COMPILE_CPP
+#define LODEPNG_COMPILE_CPP
+#endif
+#endif
+
+#ifdef LODEPNG_COMPILE_PNG
+/*The PNG color types (also used for raw).*/
+typedef enum LodePNGColorType
+{
+  LCT_GREY = 0, /*greyscale: 1,2,4,8,16 bit*/
+  LCT_RGB = 2, /*RGB: 8,16 bit*/
+  LCT_PALETTE = 3, /*palette: 1,2,4,8 bit*/
+  LCT_GREY_ALPHA = 4, /*greyscale with alpha: 8,16 bit*/
+  LCT_RGBA = 6 /*RGB with alpha: 8,16 bit*/
+} LodePNGColorType;
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Converts PNG data in memory to raw pixel data.
+out: Output parameter. Pointer to buffer that will contain the raw pixel data.
+     After decoding, its size is w * h * (bytes per pixel) bytes larger than
+     initially. Bytes per pixel depends on colortype and bitdepth.
+     Must be freed after usage with free(*out).
+     Note: for 16-bit per channel colors, uses big endian format like PNG does.
+w: Output parameter. Pointer to width of pixel data.
+h: Output parameter. Pointer to height of pixel data.
+in: Memory buffer with the PNG file.
+insize: size of the in buffer.
+colortype: the desired color type for the raw output image. See explanation on PNG color types.
+bitdepth: the desired bit depth for the raw output image. See explanation on PNG color types.
+Return value: LodePNG error code (0 means no error).
+*/
+unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h,
+                               const unsigned char* in, size_t insize,
+                               LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_decode_memory, but always decodes to 32-bit RGBA raw image*/
+unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h,
+                          const unsigned char* in, size_t insize);
+
+/*Same as lodepng_decode_memory, but always decodes to 24-bit RGB raw image*/
+unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h,
+                          const unsigned char* in, size_t insize);
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load PNG from disk, from file with given name.
+Same as the other decode functions, but instead takes a filename as input.
+*/
+unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h,
+                             const char* filename,
+                             LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_decode_file, but always decodes to 32-bit RGBA raw image.*/
+unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h,
+                               const char* filename);
+
+/*Same as lodepng_decode_file, but always decodes to 24-bit RGB raw image.*/
+unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h,
+                               const char* filename);
+#endif /*LODEPNG_COMPILE_DISK*/
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Converts raw pixel data into a PNG image in memory. The colortype and bitdepth
+  of the output PNG image cannot be chosen, they are automatically determined
+  by the colortype, bitdepth and content of the input pixel data.
+  Note: for 16-bit per channel colors, needs big endian format like PNG does.
+out: Output parameter. Pointer to buffer that will contain the PNG image data.
+     Must be freed after usage with free(*out).
+outsize: Output parameter. Pointer to the size in bytes of the out buffer.
+image: The raw pixel data to encode. The size of this buffer should be
+       w * h * (bytes per pixel), bytes per pixel depends on colortype and bitdepth.
+w: width of the raw pixel data in pixels.
+h: height of the raw pixel data in pixels.
+colortype: the color type of the raw input image. See explanation on PNG color types.
+bitdepth: the bit depth of the raw input image. See explanation on PNG color types.
+Return value: LodePNG error code (0 means no error).
+*/
+unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize,
+                               const unsigned char* image, unsigned w, unsigned h,
+                               LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_encode_memory, but always encodes from 32-bit RGBA raw image.*/
+unsigned lodepng_encode32(unsigned char** out, size_t* outsize,
+                          const unsigned char* image, unsigned w, unsigned h);
+
+/*Same as lodepng_encode_memory, but always encodes from 24-bit RGB raw image.*/
+unsigned lodepng_encode24(unsigned char** out, size_t* outsize,
+                          const unsigned char* image, unsigned w, unsigned h);
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts raw pixel data into a PNG file on disk.
+Same as the other encode functions, but instead takes a filename as output.
+NOTE: This overwrites existing files without warning!
+*/
+unsigned lodepng_encode_file(const char* filename,
+                             const unsigned char* image, unsigned w, unsigned h,
+                             LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_encode_file, but always encodes from 32-bit RGBA raw image.*/
+unsigned lodepng_encode32_file(const char* filename,
+                               const unsigned char* image, unsigned w, unsigned h);
+
+/*Same as lodepng_encode_file, but always encodes from 24-bit RGB raw image.*/
+unsigned lodepng_encode24_file(const char* filename,
+                               const unsigned char* image, unsigned w, unsigned h);
+#endif /*LODEPNG_COMPILE_DISK*/
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+
+#ifdef LODEPNG_COMPILE_CPP
+namespace lodepng
+{
+#ifdef LODEPNG_COMPILE_DECODER
+/*Same as lodepng_decode_memory, but decodes to an std::vector.*/
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                const unsigned char* in, size_t insize,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                const std::vector<unsigned char>& in,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts PNG file from disk to raw pixel data in memory.
+Same as the other decode functions, but instead takes a filename as input.
+*/
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                const std::string& filename,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#endif //LODEPNG_COMPILE_DISK
+#endif //LODEPNG_COMPILE_DECODER
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*Same as lodepng_encode_memory, but encodes to an std::vector.*/
+unsigned encode(std::vector<unsigned char>& out,
+                const unsigned char* in, unsigned w, unsigned h,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned encode(std::vector<unsigned char>& out,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts 32-bit RGBA raw pixel data into a PNG file on disk.
+Same as the other encode functions, but instead takes a filename as output.
+NOTE: This overwrites existing files without warning!
+*/
+unsigned encode(const std::string& filename,
+                const unsigned char* in, unsigned w, unsigned h,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned encode(const std::string& filename,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#endif //LODEPNG_COMPILE_DISK
+#endif //LODEPNG_COMPILE_ENCODER
+} //namespace lodepng
+#endif /*LODEPNG_COMPILE_CPP*/
+#endif /*LODEPNG_COMPILE_PNG*/
+
+#ifdef LODEPNG_COMPILE_ERROR_TEXT
+/*Returns an English description of the numerical error code.*/
+const char* lodepng_error_text(unsigned code);
+#endif /*LODEPNG_COMPILE_ERROR_TEXT*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*Settings for zlib decompression*/
+typedef struct LodePNGDecompressSettings LodePNGDecompressSettings;
+struct LodePNGDecompressSettings
+{
+  unsigned ignore_adler32; /*if 1, continue and don't give an error message if the Adler32 checksum is corrupted*/
+
+  /*use custom zlib decoder instead of built in one (default: null)*/
+  unsigned (*custom_zlib)(unsigned char**, size_t*,
+                          const unsigned char*, size_t,
+                          const LodePNGDecompressSettings*);
+  /*use custom deflate decoder instead of built in one (default: null)
+  if custom_zlib is used, custom_deflate is ignored since only the built in
+  zlib function will call custom_deflate*/
+  unsigned (*custom_inflate)(unsigned char**, size_t*,
+                             const unsigned char*, size_t,
+                             const LodePNGDecompressSettings*);
+
+  void* custom_context; /*optional custom settings for custom functions*/
+};
+
+extern const LodePNGDecompressSettings lodepng_default_decompress_settings;
+void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Settings for zlib compression. Tweaking these settings tweaks the balance
+between speed and compression ratio.
+*/
+typedef struct LodePNGCompressSettings LodePNGCompressSettings;
+struct LodePNGCompressSettings /*deflate = compress*/
+{
+  /*LZ77 related settings*/
+  unsigned btype; /*the block type for LZ (0, 1, 2 or 3, see zlib standard). Should be 2 for proper compression.*/
+  unsigned use_lz77; /*whether or not to use LZ77. Should be 1 for proper compression.*/
+  unsigned windowsize; /*the maximum is 32768, higher gives more compression but is slower. Typical value: 2048.*/
+  unsigned minmatch; /*mininum lz77 length. 3 is normally best, 6 can be better for some PNGs. Default: 0*/
+  unsigned nicematch; /*stop searching if >= this length found. Set to 258 for best compression. Default: 128*/
+  unsigned lazymatching; /*use lazy matching: better compression but a bit slower. Default: true*/
+
+  /*use custom zlib encoder instead of built in one (default: null)*/
+  unsigned (*custom_zlib)(unsigned char**, size_t*,
+                          const unsigned char*, size_t,
+                          const LodePNGCompressSettings*);
+  /*use custom deflate encoder instead of built in one (default: null)
+  if custom_zlib is used, custom_deflate is ignored since only the built in
+  zlib function will call custom_deflate*/
+  unsigned (*custom_deflate)(unsigned char**, size_t*,
+                             const unsigned char*, size_t,
+                             const LodePNGCompressSettings*);
+
+  void* custom_context; /*optional custom settings for custom functions*/
+};
+
+extern const LodePNGCompressSettings lodepng_default_compress_settings;
+void lodepng_compress_settings_init(LodePNGCompressSettings* settings);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_PNG
+/*
+Color mode of an image. Contains all information required to decode the pixel
+bits to RGBA colors. This information is the same as used in the PNG file
+format, and is used both for PNG and raw image data in LodePNG.
+*/
+typedef struct LodePNGColorMode
+{
+  /*header (IHDR)*/
+  LodePNGColorType colortype; /*color type, see PNG standard or documentation further in this header file*/
+  unsigned bitdepth;  /*bits per sample, see PNG standard or documentation further in this header file*/
+
+  /*
+  palette (PLTE and tRNS)
+
+  Dynamically allocated with the colors of the palette, including alpha.
+  When encoding a PNG, to store your colors in the palette of the LodePNGColorMode, first use
+  lodepng_palette_clear, then for each color use lodepng_palette_add.
+  If you encode an image without alpha with palette, don't forget to put value 255 in each A byte of the palette.
+
+  When decoding, by default you can ignore this palette, since LodePNG already
+  fills the palette colors in the pixels of the raw RGBA output.
+
+  The palette is only supported for color type 3.
+  */
+  unsigned char* palette; /*palette in RGBARGBA... order*/
+  size_t palettesize; /*palette size in number of colors (amount of bytes is 4 * palettesize)*/
+
+  /*
+  transparent color key (tRNS)
+
+  This color uses the same bit depth as the bitdepth value in this struct, which can be 1-bit to 16-bit.
+  For greyscale PNGs, r, g and b will all 3 be set to the same.
+
+  When decoding, by default you can ignore this information, since LodePNG sets
+  pixels with this key to transparent already in the raw RGBA output.
+
+  The color key is only supported for color types 0 and 2.
+  */
+  unsigned key_defined; /*is a transparent color key given? 0 = false, 1 = true*/
+  unsigned key_r;       /*red/greyscale component of color key*/
+  unsigned key_g;       /*green component of color key*/
+  unsigned key_b;       /*blue component of color key*/
+} LodePNGColorMode;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_color_mode_init(LodePNGColorMode* info);
+void lodepng_color_mode_cleanup(LodePNGColorMode* info);
+/*return value is error code (0 means no error)*/
+unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source);
+
+void lodepng_palette_clear(LodePNGColorMode* info);
+/*add 1 color to the palette*/
+unsigned lodepng_palette_add(LodePNGColorMode* info,
+                             unsigned char r, unsigned char g, unsigned char b, unsigned char a);
+
+/*get the total amount of bits per pixel, based on colortype and bitdepth in the struct*/
+unsigned lodepng_get_bpp(const LodePNGColorMode* info);
+/*get the amount of color channels used, based on colortype in the struct.
+If a palette is used, it counts as 1 channel.*/
+unsigned lodepng_get_channels(const LodePNGColorMode* info);
+/*is it a greyscale type? (only colortype 0 or 4)*/
+unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info);
+/*has it got an alpha channel? (only colortype 2 or 6)*/
+unsigned lodepng_is_alpha_type(const LodePNGColorMode* info);
+/*has it got a palette? (only colortype 3)*/
+unsigned lodepng_is_palette_type(const LodePNGColorMode* info);
+/*only returns true if there is a palette and there is a value in the palette with alpha < 255.
+Loops through the palette to check this.*/
+unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info);
+/*
+Check if the given color info indicates the possibility of having non-opaque pixels in the PNG image.
+Returns true if the image can have translucent or invisible pixels (it still be opaque if it doesn't use such pixels).
+Returns false if the image can only have opaque pixels.
+In detail, it returns true only if it's a color type with alpha, or has a palette with non-opaque values,
+or if "key_defined" is true.
+*/
+unsigned lodepng_can_have_alpha(const LodePNGColorMode* info);
+/*Returns the byte size of a raw image buffer with given width, height and color mode*/
+size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color);
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+/*The information of a Time chunk in PNG.*/
+typedef struct LodePNGTime
+{
+  unsigned year;    /*2 bytes used (0-65535)*/
+  unsigned month;   /*1-12*/
+  unsigned day;     /*1-31*/
+  unsigned hour;    /*0-23*/
+  unsigned minute;  /*0-59*/
+  unsigned second;  /*0-60 (to allow for leap seconds)*/
+} LodePNGTime;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+/*Information about the PNG image, except pixels, width and height.*/
+typedef struct LodePNGInfo
+{
+  /*header (IHDR), palette (PLTE) and transparency (tRNS) chunks*/
+  unsigned compression_method;/*compression method of the original file. Always 0.*/
+  unsigned filter_method;     /*filter method of the original file*/
+  unsigned interlace_method;  /*interlace method of the original file*/
+  LodePNGColorMode color;     /*color type and bits, palette and transparency of the PNG file*/
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  /*
+  suggested background color chunk (bKGD)
+  This color uses the same color mode as the PNG (except alpha channel), which can be 1-bit to 16-bit.
+
+  For greyscale PNGs, r, g and b will all 3 be set to the same. When encoding
+  the encoder writes the red one. For palette PNGs: When decoding, the RGB value
+  will be stored, not a palette index. But when encoding, specify the index of
+  the palette in background_r, the other two are then ignored.
+
+  The decoder does not use this background color to edit the color of pixels.
+  */
+  unsigned background_defined; /*is a suggested background color given?*/
+  unsigned background_r;       /*red component of suggested background color*/
+  unsigned background_g;       /*green component of suggested background color*/
+  unsigned background_b;       /*blue component of suggested background color*/
+
+  /*
+  non-international text chunks (tEXt and zTXt)
+
+  The char** arrays each contain num strings. The actual messages are in
+  text_strings, while text_keys are keywords that give a short description what
+  the actual text represents, e.g. Title, Author, Description, or anything else.
+
+  A keyword is minimum 1 character and maximum 79 characters long. It's
+  discouraged to use a single line length longer than 79 characters for texts.
+
+  Don't allocate these text buffers yourself. Use the init/cleanup functions
+  correctly and use lodepng_add_text and lodepng_clear_text.
+  */
+  size_t text_num; /*the amount of texts in these char** buffers (there may be more texts in itext)*/
+  char** text_keys; /*the keyword of a text chunk (e.g. "Comment")*/
+  char** text_strings; /*the actual text*/
+
+  /*
+  international text chunks (iTXt)
+  Similar to the non-international text chunks, but with additional strings
+  "langtags" and "transkeys".
+  */
+  size_t itext_num; /*the amount of international texts in this PNG*/
+  char** itext_keys; /*the English keyword of the text chunk (e.g. "Comment")*/
+  char** itext_langtags; /*language tag for this text's language, ISO/IEC 646 string, e.g. ISO 639 language tag*/
+  char** itext_transkeys; /*keyword translated to the international language - UTF-8 string*/
+  char** itext_strings; /*the actual international text - UTF-8 string*/
+
+  /*time chunk (tIME)*/
+  unsigned time_defined; /*set to 1 to make the encoder generate a tIME chunk*/
+  LodePNGTime time;
+
+  /*phys chunk (pHYs)*/
+  unsigned phys_defined; /*if 0, there is no pHYs chunk and the values below are undefined, if 1 else there is one*/
+  unsigned phys_x; /*pixels per unit in x direction*/
+  unsigned phys_y; /*pixels per unit in y direction*/
+  unsigned phys_unit; /*may be 0 (unknown unit) or 1 (metre)*/
+
+  /*
+  unknown chunks
+  There are 3 buffers, one for each position in the PNG where unknown chunks can appear
+  each buffer contains all unknown chunks for that position consecutively
+  The 3 buffers are the unknown chunks between certain critical chunks:
+  0: IHDR-PLTE, 1: PLTE-IDAT, 2: IDAT-IEND
+  Do not allocate or traverse this data yourself. Use the chunk traversing functions declared
+  later, such as lodepng_chunk_next and lodepng_chunk_append, to read/write this struct.
+  */
+  unsigned char* unknown_chunks_data[3];
+  size_t unknown_chunks_size[3]; /*size in bytes of the unknown chunks, given for protection*/
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGInfo;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_info_init(LodePNGInfo* info);
+void lodepng_info_cleanup(LodePNGInfo* info);
+/*return value is error code (0 means no error)*/
+unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source);
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+void lodepng_clear_text(LodePNGInfo* info); /*use this to clear the texts again after you filled them in*/
+unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str); /*push back both texts at once*/
+
+void lodepng_clear_itext(LodePNGInfo* info); /*use this to clear the itexts again after you filled them in*/
+unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag,
+                           const char* transkey, const char* str); /*push back the 4 texts of 1 chunk at once*/
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+/*
+Converts raw buffer from one color type to another color type, based on
+LodePNGColorMode structs to describe the input and output color type.
+See the reference manual at the end of this header file to see which color conversions are supported.
+return value = LodePNG error code (0 if all went ok, an error if the conversion isn't supported)
+The out buffer must have size (w * h * bpp + 7) / 8, where bpp is the bits per pixel
+of the output color type (lodepng_get_bpp)
+Note: for 16-bit per channel colors, uses big endian format like PNG does.
+*/
+unsigned lodepng_convert(unsigned char* out, const unsigned char* in,
+                         LodePNGColorMode* mode_out, LodePNGColorMode* mode_in,
+                         unsigned w, unsigned h);
+
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Settings for the decoder. This contains settings for the PNG and the Zlib
+decoder, but not the Info settings from the Info structs.
+*/
+typedef struct LodePNGDecoderSettings
+{
+  LodePNGDecompressSettings zlibsettings; /*in here is the setting to ignore Adler32 checksums*/
+
+  unsigned ignore_crc; /*ignore CRC checksums*/
+  unsigned color_convert; /*whether to convert the PNG to the color type you want. Default: yes*/
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  unsigned read_text_chunks; /*if false but remember_unknown_chunks is true, they're stored in the unknown chunks*/
+  /*store all bytes from unknown chunks in the LodePNGInfo (off by default, useful for a png editor)*/
+  unsigned remember_unknown_chunks;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGDecoderSettings;
+
+void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*automatically use color type with less bits per pixel if losslessly possible. Default: AUTO*/
+typedef enum LodePNGFilterStrategy
+{
+  /*every filter at zero*/
+  LFS_ZERO,
+  /*Use filter that gives minumum sum, as described in the official PNG filter heuristic.*/
+  LFS_MINSUM,
+  /*Use the filter type that gives smallest Shannon entropy for this scanline. Depending
+  on the image, this is better or worse than minsum.*/
+  LFS_ENTROPY,
+  /*
+  Brute-force-search PNG filters by compressing each filter for each scanline.
+  Experimental, very slow, and only rarely gives better compression than MINSUM.
+  */
+  LFS_BRUTE_FORCE,
+  /*use predefined_filters buffer: you specify the filter type for each scanline*/
+  LFS_PREDEFINED
+} LodePNGFilterStrategy;
+
+/*automatically use color type with less bits per pixel if losslessly possible. Default: LAC_AUTO*/
+typedef enum LodePNGAutoConvert
+{
+  LAC_NO, /*use color type user requested*/
+  LAC_ALPHA, /*use color type user requested, but if only opaque pixels and RGBA or grey+alpha, use RGB or grey*/
+  LAC_AUTO, /*use PNG color type that can losslessly represent the uncompressed image the smallest possible*/
+  /*
+  like AUTO, but do not choose 1, 2 or 4 bit per pixel types.
+  sometimes a PNG image compresses worse if less than 8 bits per pixels.
+  */
+  LAC_AUTO_NO_NIBBLES,
+  /*
+  like AUTO, but never choose palette color type. For small images, encoding
+  the palette may take more bytes than what is gained. Note that AUTO also
+  already prevents encoding the palette for extremely small images, but that may
+  not be sufficient because due to the compression it cannot predict when to
+  switch.
+  */
+  LAC_AUTO_NO_PALETTE,
+  LAC_AUTO_NO_NIBBLES_NO_PALETTE
+} LodePNGAutoConvert;
+
+
+/*Settings for the encoder.*/
+typedef struct LodePNGEncoderSettings
+{
+  LodePNGCompressSettings zlibsettings; /*settings for the zlib encoder, such as window size, ...*/
+
+  LodePNGAutoConvert auto_convert; /*how to automatically choose output PNG color type, if at all*/
+
+  /*If true, follows the official PNG heuristic: if the PNG uses a palette or lower than
+  8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to
+  completely follow the official PNG heuristic, filter_palette_zero must be true and
+  filter_strategy must be LFS_MINSUM*/
+  unsigned filter_palette_zero;
+  /*Which filter strategy to use when not using zeroes due to filter_palette_zero.
+  Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM*/
+  LodePNGFilterStrategy filter_strategy;
+  /*used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with
+  the same length as the amount of scanlines in the image, and each value must <= 5. You
+  have to cleanup this buffer, LodePNG will never free it. Don't forget that filter_palette_zero
+  must be set to 0 to ensure this is also used on palette or low bitdepth images.*/
+  unsigned char* predefined_filters;
+
+  /*force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette).
+  If colortype is 3, PLTE is _always_ created.*/
+  unsigned force_palette;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+  /*add LodePNG identifier and version as a text chunk, for debugging*/
+  unsigned add_id;
+  /*encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks*/
+  unsigned text_compression;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGEncoderSettings;
+
+void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+
+#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER)
+/*The settings, state and information for extended encoding and decoding.*/
+typedef struct LodePNGState
+{
+#ifdef LODEPNG_COMPILE_DECODER
+  LodePNGDecoderSettings decoder; /*the decoding settings*/
+#endif /*LODEPNG_COMPILE_DECODER*/
+#ifdef LODEPNG_COMPILE_ENCODER
+  LodePNGEncoderSettings encoder; /*the encoding settings*/
+#endif /*LODEPNG_COMPILE_ENCODER*/
+  LodePNGColorMode info_raw; /*specifies the format in which you would like to get the raw pixel buffer*/
+  LodePNGInfo info_png; /*info of the PNG image obtained after decoding*/
+  unsigned error;
+#ifdef LODEPNG_COMPILE_CPP
+  //For the lodepng::State subclass.
+  virtual ~LodePNGState(){}
+#endif
+} LodePNGState;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_state_init(LodePNGState* state);
+void lodepng_state_cleanup(LodePNGState* state);
+void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source);
+#endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Same as lodepng_decode_memory, but uses a LodePNGState to allow custom settings and
+getting much more information about the PNG image and color mode.
+*/
+unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h,
+                        LodePNGState* state,
+                        const unsigned char* in, size_t insize);
+
+/*
+Read the PNG header, but not the actual data. This returns only the information
+that is in the header chunk of the PNG, such as width, height and color type. The
+information is placed in the info_png field of the LodePNGState.
+*/
+unsigned lodepng_inspect(unsigned* w, unsigned* h,
+                         LodePNGState* state,
+                         const unsigned char* in, size_t insize);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*This function allocates the out buffer with standard malloc and stores the size in *outsize.*/
+unsigned lodepng_encode(unsigned char** out, size_t* outsize,
+                        const unsigned char* image, unsigned w, unsigned h,
+                        LodePNGState* state);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+/*
+The lodepng_chunk functions are normally not needed, except to traverse the
+unknown chunks stored in the LodePNGInfo struct, or add new ones to it.
+It also allows traversing the chunks of an encoded PNG file yourself.
+
+PNG standard chunk naming conventions:
+First byte: uppercase = critical, lowercase = ancillary
+Second byte: uppercase = public, lowercase = private
+Third byte: must be uppercase
+Fourth byte: uppercase = unsafe to copy, lowercase = safe to copy
+*/
+
+/*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
+unsigned lodepng_chunk_length(const unsigned char* chunk);
+
+/*puts the 4-byte type in null terminated string*/
+void lodepng_chunk_type(char type[5], const unsigned char* chunk);
+
+/*check if the type is the given type*/
+unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type);
+
+/*0: it's one of the critical chunk types, 1: it's an ancillary chunk (see PNG standard)*/
+unsigned char lodepng_chunk_ancillary(const unsigned char* chunk);
+
+/*0: public, 1: private (see PNG standard)*/
+unsigned char lodepng_chunk_private(const unsigned char* chunk);
+
+/*0: the chunk is unsafe to copy, 1: the chunk is safe to copy (see PNG standard)*/
+unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk);
+
+/*get pointer to the data of the chunk, where the input points to the header of the chunk*/
+unsigned char* lodepng_chunk_data(unsigned char* chunk);
+const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk);
+
+/*returns 0 if the crc is correct, 1 if it's incorrect (0 for OK as usual!)*/
+unsigned lodepng_chunk_check_crc(const unsigned char* chunk);
+
+/*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
+void lodepng_chunk_generate_crc(unsigned char* chunk);
+
+/*iterate to next chunks. don't use on IEND chunk, as there is no next chunk then*/
+unsigned char* lodepng_chunk_next(unsigned char* chunk);
+const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk);
+
+/*
+Appends chunk to the data in out. The given chunk should already have its chunk header.
+The out variable and outlength are updated to reflect the new reallocated buffer.
+Returns error code (0 if it went ok)
+*/
+unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk);
+
+/*
+Appends new chunk to out. The chunk to append is given by giving its length, type
+and data separately. The type is a 4-letter string.
+The out variable and outlength are updated to reflect the new reallocated buffer.
+Returne error code (0 if it went ok)
+*/
+unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
+                              const char* type, const unsigned char* data);
+
+
+/*Calculate CRC32 of buffer*/
+unsigned lodepng_crc32(const unsigned char* buf, size_t len);
+#endif /*LODEPNG_COMPILE_PNG*/
+
+
+#ifdef LODEPNG_COMPILE_ZLIB
+/*
+This zlib part can be used independently to zlib compress and decompress a
+buffer. It cannot be used to create gzip files however, and it only supports the
+part of zlib that is required for PNG, it does not support dictionaries.
+*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*Inflate a buffer. Inflate is the decompression step of deflate. Out buffer must be freed after use.*/
+unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
+                         const unsigned char* in, size_t insize,
+                         const LodePNGDecompressSettings* settings);
+
+/*
+Decompresses Zlib data. Reallocates the out buffer and appends the data. The
+data must be according to the zlib specification.
+Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
+buffer and *outsize its size in bytes. out must be freed by user after usage.
+*/
+unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize,
+                                 const unsigned char* in, size_t insize,
+                                 const LodePNGDecompressSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Compresses data with Zlib. Reallocates the out buffer and appends the data.
+Zlib adds a small header and trailer around the deflate data.
+The data is output in the format of the zlib specification.
+Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
+buffer and *outsize its size in bytes. out must be freed by user after usage.
+*/
+unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize,
+                               const unsigned char* in, size_t insize,
+                               const LodePNGCompressSettings* settings);
+
+/*
+Find length-limited Huffman code for given frequencies. This function is in the
+public interface only for tests, it's used internally by lodepng_deflate.
+*/
+unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies,
+                                      size_t numcodes, unsigned maxbitlen);
+
+/*Compress a buffer with deflate. See RFC 1951. Out buffer must be freed after use.*/
+unsigned lodepng_deflate(unsigned char** out, size_t* outsize,
+                         const unsigned char* in, size_t insize,
+                         const LodePNGCompressSettings* settings);
+
+#endif /*LODEPNG_COMPILE_ENCODER*/
+#endif /*LODEPNG_COMPILE_ZLIB*/
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load a file from disk into buffer. The function allocates the out buffer, and
+after usage you should free it.
+out: output parameter, contains pointer to loaded buffer.
+outsize: output parameter, size of the allocated out buffer
+filename: the path to the file to load
+return value: error code (0 means ok)
+*/
+unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename);
+
+/*
+Save a file from buffer to disk. Warning, if it exists, this function overwrites
+the file without warning!
+buffer: the buffer to write
+buffersize: size of the buffer to write
+filename: the path to the file to save to
+return value: error code (0 means ok)
+*/
+unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename);
+#endif /*LODEPNG_COMPILE_DISK*/
+
+#ifdef LODEPNG_COMPILE_CPP
+//The LodePNG C++ wrapper uses std::vectors instead of manually allocated memory buffers.
+namespace lodepng
+{
+#ifdef LODEPNG_COMPILE_PNG
+class State : public LodePNGState
+{
+  public:
+    State();
+    State(const State& other);
+    virtual ~State();
+    State& operator=(const State& other);
+};
+
+#ifdef LODEPNG_COMPILE_DECODER
+//Same as other lodepng::decode, but using a State for more settings and information.
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                State& state,
+                const unsigned char* in, size_t insize);
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+                State& state,
+                const std::vector<unsigned char>& in);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+//Same as other lodepng::encode, but using a State for more settings and information.
+unsigned encode(std::vector<unsigned char>& out,
+                const unsigned char* in, unsigned w, unsigned h,
+                State& state);
+unsigned encode(std::vector<unsigned char>& out,
+                const std::vector<unsigned char>& in, unsigned w, unsigned h,
+                State& state);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load a file from disk into an std::vector. If the vector is empty, then either
+the file doesn't exist or is an empty file.
+*/
+void load_file(std::vector<unsigned char>& buffer, const std::string& filename);
+
+/*
+Save the binary data in an std::vector to a file on disk. The file is overwritten
+without warning.
+*/
+void save_file(const std::vector<unsigned char>& buffer, const std::string& filename);
+#endif //LODEPNG_COMPILE_DISK
+#endif //LODEPNG_COMPILE_PNG
+
+#ifdef LODEPNG_COMPILE_ZLIB
+#ifdef LODEPNG_COMPILE_DECODER
+//Zlib-decompress an unsigned char buffer
+unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+                    const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
+
+//Zlib-decompress an std::vector
+unsigned decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+                    const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
+#endif //LODEPNG_COMPILE_DECODER
+
+#ifdef LODEPNG_COMPILE_ENCODER
+//Zlib-compress an unsigned char buffer
+unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+                  const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
+
+//Zlib-compress an std::vector
+unsigned compress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+                  const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
+#endif //LODEPNG_COMPILE_ENCODER
+#endif //LODEPNG_COMPILE_ZLIB
+} //namespace lodepng
+#endif /*LODEPNG_COMPILE_CPP*/
+
+/*
+TODO:
+[.] test if there are no memory leaks or security exploits - done a lot but needs to be checked often
+[.] check compatibility with vareous compilers  - done but needs to be redone for every newer version
+[X] converting color to 16-bit per channel types
+[ ] read all public PNG chunk types (but never let the color profile and gamma ones touch RGB values)
+[ ] make sure encoder generates no chunks with size > (2^31)-1
+[ ] partial decoding (stream processing)
+[X] let the "isFullyOpaque" function check color keys and transparent palettes too
+[X] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl"
+[ ] don't stop decoding on errors like 69, 57, 58 (make warnings)
+[ ] make option to choose if the raw image with non multiple of 8 bits per scanline should have padding bits or not
+[ ] let the C++ wrapper catch exceptions coming from the standard library and return LodePNG error codes
+*/
+
+#endif /*LODEPNG_H inclusion guard*/
+
+/*
+LodePNG Documentation
+---------------------
+
+0. table of contents
+--------------------
+
+  1. about
+   1.1. supported features
+   1.2. features not supported
+  2. C and C++ version
+  3. security
+  4. decoding
+  5. encoding
+  6. color conversions
+    6.1. PNG color types
+    6.2. color conversions
+    6.3. padding bits
+    6.4. A note about 16-bits per channel and endianness
+  7. error values
+  8. chunks and PNG editing
+  9. compiler support
+  10. examples
+   10.1. decoder C++ example
+   10.2. decoder C example
+  11. changes
+  12. contact information
+
+
+1. about
+--------
+
+PNG is a file format to store raster images losslessly with good compression,
+supporting different color types and alpha channel.
+
+LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
+Specification (Second Edition) - W3C Recommendation 10 November 2003.
+
+The specifications used are:
+
+*) Portable Network Graphics (PNG) Specification (Second Edition):
+     http://www.w3.org/TR/2003/REC-PNG-20031110
+*) RFC 1950 ZLIB Compressed Data Format version 3.3:
+     http://www.gzip.org/zlib/rfc-zlib.html
+*) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3:
+     http://www.gzip.org/zlib/rfc-deflate.html
+
+The most recent version of LodePNG can currently be found at
+http://lodev.org/lodepng/
+
+LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds
+extra functionality.
+
+LodePNG exists out of two files:
+-lodepng.h: the header file for both C and C++
+-lodepng.c(pp): give it the name lodepng.c or lodepng.cpp (or .cc) depending on your usage
+
+If you want to start using LodePNG right away without reading this doc, get the
+examples from the LodePNG website to see how to use it in code, or check the
+smaller examples in chapter 13 here.
+
+LodePNG is simple but only supports the basic requirements. To achieve
+simplicity, the following design choices were made: There are no dependencies
+on any external library. There are functions to decode and encode a PNG with
+a single function call, and extended versions of these functions taking a
+LodePNGState struct allowing to specify or get more information. By default
+the colors of the raw image are always RGB or RGBA, no matter what color type
+the PNG file uses. To read and write files, there are simple functions to
+convert the files to/from buffers in memory.
+
+This all makes LodePNG suitable for loading textures in games, demos and small
+programs, ... It's less suitable for full fledged image editors, loading PNGs
+over network (it requires all the image data to be available before decoding can
+begin), life-critical systems, ...
+
+1.1. supported features
+-----------------------
+
+The following features are supported by the decoder:
+
+*) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image,
+   or the same color type as the PNG
+*) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image
+*) Adam7 interlace and deinterlace for any color type
+*) loading the image from harddisk or decoding it from a buffer from other sources than harddisk
+*) support for alpha channels, including RGBA color model, translucent palettes and color keying
+*) zlib decompression (inflate)
+*) zlib compression (deflate)
+*) CRC32 and ADLER32 checksums
+*) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks.
+*) the following chunks are supported (generated/interpreted) by both encoder and decoder:
+    IHDR: header information
+    PLTE: color palette
+    IDAT: pixel data
+    IEND: the final chunk
+    tRNS: transparency for palettized images
+    tEXt: textual information
+    zTXt: compressed textual information
+    iTXt: international textual information
+    bKGD: suggested background color
+    pHYs: physical dimensions
+    tIME: modification time
+
+1.2. features not supported
+---------------------------
+
+The following features are _not_ supported:
+
+*) some features needed to make a conformant PNG-Editor might be still missing.
+*) partial loading/stream processing. All data must be available and is processed in one call.
+*) The following public chunks are not supported but treated as unknown chunks by LodePNG
+    cHRM, gAMA, iCCP, sRGB, sBIT, hIST, sPLT
+   Some of these are not supported on purpose: LodePNG wants to provide the RGB values
+   stored in the pixels, not values modified by system dependent gamma or color models.
+
+
+2. C and C++ version
+--------------------
+
+The C version uses buffers allocated with alloc that you need to free()
+yourself. You need to use init and cleanup functions for each struct whenever
+using a struct from the C version to avoid exploits and memory leaks.
+
+The C++ version has extra functions with std::vectors in the interface and the
+lodepng::State class which is a LodePNGState with constructor and destructor.
+
+These files work without modification for both C and C++ compilers because all
+the additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers
+ignore it, and the C code is made to compile both with strict ISO C90 and C++.
+
+To use the C++ version, you need to rename the source file to lodepng.cpp
+(instead of lodepng.c), and compile it with a C++ compiler.
+
+To use the C version, you need to rename the source file to lodepng.c (instead
+of lodepng.cpp), and compile it with a C compiler.
+
+
+3. Security
+-----------
+
+Even if carefully designed, it's always possible that LodePNG contains possible
+exploits. If you discover one, please let me know, and it will be fixed.
+
+When using LodePNG, care has to be taken with the C version of LodePNG, as well
+as the C-style structs when working with C++. The following conventions are used
+for all C-style structs:
+
+-if a struct has a corresponding init function, always call the init function when making a new one
+-if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks
+-if a struct has a corresponding copy function, use the copy function instead of "=".
+ The destination must also be inited already.
+
+
+4. Decoding
+-----------
+
+Decoding converts a PNG compressed image to a raw pixel buffer.
+
+Most documentation on using the decoder is at its declarations in the header
+above. For C, simple decoding can be done with functions such as
+lodepng_decode32, and more advanced decoding can be done with the struct
+LodePNGState and lodepng_decode. For C++, all decoding can be done with the
+various lodepng::decode functions, and lodepng::State can be used for advanced
+features.
+
+When using the LodePNGState, it uses the following fields for decoding:
+*) LodePNGInfo info_png: it stores extra information about the PNG (the input) in here
+*) LodePNGColorMode info_raw: here you can say what color mode of the raw image (the output) you want to get
+*) LodePNGDecoderSettings decoder: you can specify a few extra settings for the decoder to use
+
+LodePNGInfo info_png
+--------------------
+
+After decoding, this contains extra information of the PNG image, except the actual
+pixels, width and height because these are already gotten directly from the decoder
+functions.
+
+It contains for example the original color type of the PNG image, text comments,
+suggested background color, etc... More details about the LodePNGInfo struct are
+at its declaration documentation.
+
+LodePNGColorMode info_raw
+-------------------------
+
+When decoding, here you can specify which color type you want
+the resulting raw image to be. If this is different from the colortype of the
+PNG, then the decoder will automatically convert the result. This conversion
+always works, except if you want it to convert a color PNG to greyscale or to
+a palette with missing colors.
+
+By default, 32-bit color is used for the result.
+
+LodePNGDecoderSettings decoder
+------------------------------
+
+The settings can be used to ignore the errors created by invalid CRC and Adler32
+chunks, and to disable the decoding of tEXt chunks.
+
+There's also a setting color_convert, true by default. If false, no conversion
+is done, the resulting data will be as it was in the PNG (after decompression)
+and you'll have to puzzle the colors of the pixels together yourself using the
+color type information in the LodePNGInfo.
+
+
+5. Encoding
+-----------
+
+Encoding converts a raw pixel buffer to a PNG compressed image.
+
+Most documentation on using the encoder is at its declarations in the header
+above. For C, simple encoding can be done with functions such as
+lodepng_encode32, and more advanced decoding can be done with the struct
+LodePNGState and lodepng_encode. For C++, all encoding can be done with the
+various lodepng::encode functions, and lodepng::State can be used for advanced
+features.
+
+Like the decoder, the encoder can also give errors. However it gives less errors
+since the encoder input is trusted, the decoder input (a PNG image that could
+be forged by anyone) is not trusted.
+
+When using the LodePNGState, it uses the following fields for encoding:
+*) LodePNGInfo info_png: here you specify how you want the PNG (the output) to be.
+*) LodePNGColorMode info_raw: here you say what color type of the raw image (the input) has
+*) LodePNGEncoderSettings encoder: you can specify a few settings for the encoder to use
+
+LodePNGInfo info_png
+--------------------
+
+When encoding, you use this the opposite way as when decoding: for encoding,
+you fill in the values you want the PNG to have before encoding. By default it's
+not needed to specify a color type for the PNG since it's automatically chosen,
+but it's possible to choose it yourself given the right settings.
+
+The encoder will not always exactly match the LodePNGInfo struct you give,
+it tries as close as possible. Some things are ignored by the encoder. The
+encoder uses, for example, the following settings from it when applicable:
+colortype and bitdepth, text chunks, time chunk, the color key, the palette, the
+background color, the interlace method, unknown chunks, ...
+
+When encoding to a PNG with colortype 3, the encoder will generate a PLTE chunk.
+If the palette contains any colors for which the alpha channel is not 255 (so
+there are translucent colors in the palette), it'll add a tRNS chunk.
+
+LodePNGColorMode info_raw
+-------------------------
+
+You specify the color type of the raw image that you give to the input here,
+including a possible transparent color key and palette you happen to be using in
+your raw image data.
+
+By default, 32-bit color is assumed, meaning your input has to be in RGBA
+format with 4 bytes (unsigned chars) per pixel.
+
+LodePNGEncoderSettings encoder
+------------------------------
+
+The following settings are supported (some are in sub-structs):
+*) auto_convert: when this option is enabled, the encoder will
+automatically choose the smallest possible color mode (including color key) that
+can encode the colors of all pixels without information loss.
+*) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree,
+   2 = dynamic huffman tree (best compression). Should be 2 for proper
+   compression.
+*) use_lz77: whether or not to use LZ77 for compressed block types. Should be
+   true for proper compression.
+*) windowsize: the window size used by the LZ77 encoder (1 - 32768). Has value
+   2048 by default, but can be set to 32768 for better, but slow, compression.
+*) force_palette: if colortype is 2 or 6, you can make the encoder write a PLTE
+   chunk if force_palette is true. This can used as suggested palette to convert
+   to by viewers that don't support more than 256 colors (if those still exist)
+*) add_id: add text chunk "Encoder: LodePNG <version>" to the image.
+*) text_compression: default 1. If 1, it'll store texts as zTXt instead of tEXt chunks.
+  zTXt chunks use zlib compression on the text. This gives a smaller result on
+  large texts but a larger result on small texts (such as a single program name).
+  It's all tEXt or all zTXt though, there's no separate setting per text yet.
+
+
+6. color conversions
+--------------------
+
+An important thing to note about LodePNG, is that the color type of the PNG, and
+the color type of the raw image, are completely independent. By default, when
+you decode a PNG, you get the result as a raw image in the color type you want,
+no matter whether the PNG was encoded with a palette, greyscale or RGBA color.
+And if you encode an image, by default LodePNG will automatically choose the PNG
+color type that gives good compression based on the values of colors and amount
+of colors in the image. It can be configured to let you control it instead as
+well, though.
+
+To be able to do this, LodePNG does conversions from one color mode to another.
+It can convert from almost any color type to any other color type, except the
+following conversions: RGB to greyscale is not supported, and converting to a
+palette when the palette doesn't have a required color is not supported. This is
+not supported on purpose: this is information loss which requires a color
+reduction algorithm that is beyong the scope of a PNG encoder (yes, RGB to grey
+is easy, but there are multiple ways if you want to give some channels more
+weight).
+
+By default, when decoding, you get the raw image in 32-bit RGBA or 24-bit RGB
+color, no matter what color type the PNG has. And by default when encoding,
+LodePNG automatically picks the best color model for the output PNG, and expects
+the input image to be 32-bit RGBA or 24-bit RGB. So, unless you want to control
+the color format of the images yourself, you can skip this chapter.
+
+6.1. PNG color types
+--------------------
+
+A PNG image can have many color types, ranging from 1-bit color to 64-bit color,
+as well as palettized color modes. After the zlib decompression and unfiltering
+in the PNG image is done, the raw pixel data will have that color type and thus
+a certain amount of bits per pixel. If you want the output raw image after
+decoding to have another color type, a conversion is done by LodePNG.
+
+The PNG specification gives the following color types:
+
+0: greyscale, bit depths 1, 2, 4, 8, 16
+2: RGB, bit depths 8 and 16
+3: palette, bit depths 1, 2, 4 and 8
+4: greyscale with alpha, bit depths 8 and 16
+6: RGBA, bit depths 8 and 16
+
+Bit depth is the amount of bits per pixel per color channel. So the total amount
+of bits per pixel is: amount of channels * bitdepth.
+
+6.2. color conversions
+----------------------
+
+As explained in the sections about the encoder and decoder, you can specify
+color types and bit depths in info_png and info_raw to change the default
+behaviour.
+
+If, when decoding, you want the raw image to be something else than the default,
+you need to set the color type and bit depth you want in the LodePNGColorMode,
+or the parameters of the simple function of LodePNG you're using.
+
+If, when encoding, you use another color type than the default in the input
+image, you need to specify its color type and bit depth in the LodePNGColorMode
+of the raw image, or use the parameters of the simplefunction of LodePNG you're
+using.
+
+If, when encoding, you don't want LodePNG to choose the output PNG color type
+but control it yourself, you need to set auto_convert in the encoder settings
+to LAC_NONE, and specify the color type you want in the LodePNGInfo of the
+encoder.
+
+If you do any of the above, LodePNG may need to do a color conversion, which
+follows the rules below, and may sometimes not be allowed.
+
+To avoid some confusion:
+-the decoder converts from PNG to raw image
+-the encoder converts from raw image to PNG
+-the colortype and bitdepth in LodePNGColorMode info_raw, are those of the raw image
+-the colortype and bitdepth in the color field of LodePNGInfo info_png, are those of the PNG
+-when encoding, the color type in LodePNGInfo is ignored if auto_convert
+ is enabled, it is automatically generated instead
+-when decoding, the color type in LodePNGInfo is set by the decoder to that of the original
+ PNG image, but it can be ignored since the raw image has the color type you requested instead
+-if the color type of the LodePNGColorMode and PNG image aren't the same, a conversion
+ between the color types is done if the color types are supported. If it is not
+ supported, an error is returned. If the types are the same, no conversion is done.
+-even though some conversions aren't supported, LodePNG supports loading PNGs from any
+ colortype and saving PNGs to any colortype, sometimes it just requires preparing
+ the raw image correctly before encoding.
+-both encoder and decoder use the same color converter.
+
+Non supported color conversions:
+-color to greyscale: no error is thrown, but the result will look ugly because
+only the red channel is taken
+-anything, to palette when that palette does not have that color in it: in this
+case an error is thrown
+
+Supported color conversions:
+-anything to 8-bit RGB, 8-bit RGBA, 16-bit RGB, 16-bit RGBA
+-any grey or grey+alpha, to grey or grey+alpha
+-anything to a palette, as long as the palette has the requested colors in it
+-removing alpha channel
+-higher to smaller bitdepth, and vice versa
+
+If you want no color conversion to be done:
+-In the encoder, you can make it save a PNG with any color type by giving the
+raw color mode and LodePNGInfo the same color mode, and setting auto_convert to
+LAC_NO.
+-In the decoder, you can make it store the pixel data in the same color type
+as the PNG has, by setting the color_convert setting to false. Settings in
+info_raw are then ignored.
+
+The function lodepng_convert does the color conversion. It is available in the
+interface but normally isn't needed since the encoder and decoder already call
+it.
+
+6.3. padding bits
+-----------------
+
+In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines
+have a bit amount that isn't a multiple of 8, then padding bits are used so that each
+scanline starts at a fresh byte. But that is NOT true for the LodePNG raw input and output.
+The raw input image you give to the encoder, and the raw output image you get from the decoder
+will NOT have these padding bits, e.g. in the case of a 1-bit image with a width
+of 7 pixels, the first pixel of the second scanline will the the 8th bit of the first byte,
+not the first bit of a new byte.
+
+6.4. A note about 16-bits per channel and endianness
+----------------------------------------------------
+
+LodePNG uses unsigned char arrays for 16-bit per channel colors too, just like
+for any other color format. The 16-bit values are stored in big endian (most
+significant byte first) in these arrays. This is the opposite order of the
+little endian used by x86 CPU's.
+
+LodePNG always uses big endian because the PNG file format does so internally.
+Conversions to other formats than PNG uses internally are not supported by
+LodePNG on purpose, there are myriads of formats, including endianness of 16-bit
+colors, the order in which you store R, G, B and A, and so on. Supporting and
+converting to/from all that is outside the scope of LodePNG.
+
+This may mean that, depending on your use case, you may want to convert the big
+endian output of LodePNG to little endian with a for loop. This is certainly not
+always needed, many applications and libraries support big endian 16-bit colors
+anyway, but it means you cannot simply cast the unsigned char* buffer to an
+unsigned short* buffer on x86 CPUs.
+
+
+7. error values
+---------------
+
+All functions in LodePNG that return an error code, return 0 if everything went
+OK, or a non-zero code if there was an error.
+
+The meaning of the LodePNG error values can be retrieved with the function
+lodepng_error_text: given the numerical error code, it returns a description
+of the error in English as a string.
+
+Check the implementation of lodepng_error_text to see the meaning of each code.
+
+
+8. chunks and PNG editing
+-------------------------
+
+If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG
+editor that should follow the rules about handling of unknown chunks, or if your
+program is able to read other types of chunks than the ones handled by LodePNG,
+then that's possible with the chunk functions of LodePNG.
+
+A PNG chunk has the following layout:
+
+4 bytes length
+4 bytes type name
+length bytes data
+4 bytes CRC
+
+8.1. iterating through chunks
+-----------------------------
+
+If you have a buffer containing the PNG image data, then the first chunk (the
+IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the
+signature of the PNG and are not part of a chunk. But if you start at byte 8
+then you have a chunk, and can check the following things of it.
+
+NOTE: none of these functions check for memory buffer boundaries. To avoid
+exploits, always make sure the buffer contains all the data of the chunks.
+When using lodepng_chunk_next, make sure the returned value is within the
+allocated memory.
+
+unsigned lodepng_chunk_length(const unsigned char* chunk):
+
+Get the length of the chunk's data. The total chunk length is this length + 12.
+
+void lodepng_chunk_type(char type[5], const unsigned char* chunk):
+unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type):
+
+Get the type of the chunk or compare if it's a certain type
+
+unsigned char lodepng_chunk_critical(const unsigned char* chunk):
+unsigned char lodepng_chunk_private(const unsigned char* chunk):
+unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk):
+
+Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are).
+Check if the chunk is private (public chunks are part of the standard, private ones not).
+Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical
+chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your
+program doesn't handle that type of unknown chunk.
+
+unsigned char* lodepng_chunk_data(unsigned char* chunk):
+const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk):
+
+Get a pointer to the start of the data of the chunk.
+
+unsigned lodepng_chunk_check_crc(const unsigned char* chunk):
+void lodepng_chunk_generate_crc(unsigned char* chunk):
+
+Check if the crc is correct or generate a correct one.
+
+unsigned char* lodepng_chunk_next(unsigned char* chunk):
+const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk):
+
+Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these
+functions do no boundary checking of the allocated data whatsoever, so make sure there is enough
+data available in the buffer to be able to go to the next chunk.
+
+unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk):
+unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
+                              const char* type, const unsigned char* data):
+
+These functions are used to create new chunks that are appended to the data in *out that has
+length *outlength. The append function appends an existing chunk to the new data. The create
+function creates a new chunk with the given parameters and appends it. Type is the 4-letter
+name of the chunk.
+
+8.2. chunks in info_png
+-----------------------
+
+The LodePNGInfo struct contains fields with the unknown chunk in it. It has 3
+buffers (each with size) to contain 3 types of unknown chunks:
+the ones that come before the PLTE chunk, the ones that come between the PLTE
+and the IDAT chunks, and the ones that come after the IDAT chunks.
+It's necessary to make the distionction between these 3 cases because the PNG
+standard forces to keep the ordering of unknown chunks compared to the critical
+chunks, but does not force any other ordering rules.
+
+info_png.unknown_chunks_data[0] is the chunks before PLTE
+info_png.unknown_chunks_data[1] is the chunks after PLTE, before IDAT
+info_png.unknown_chunks_data[2] is the chunks after IDAT
+
+The chunks in these 3 buffers can be iterated through and read by using the same
+way described in the previous subchapter.
+
+When using the decoder to decode a PNG, you can make it store all unknown chunks
+if you set the option settings.remember_unknown_chunks to 1. By default, this
+option is off (0).
+
+The encoder will always encode unknown chunks that are stored in the info_png.
+If you need it to add a particular chunk that isn't known by LodePNG, you can
+use lodepng_chunk_append or lodepng_chunk_create to the chunk data in
+info_png.unknown_chunks_data[x].
+
+Chunks that are known by LodePNG should not be added in that way. E.g. to make
+LodePNG add a bKGD chunk, set background_defined to true and add the correct
+parameters there instead.
+
+
+9. compiler support
+-------------------
+
+No libraries other than the current standard C library are needed to compile
+LodePNG. For the C++ version, only the standard C++ library is needed on top.
+Add the files lodepng.c(pp) and lodepng.h to your project, include
+lodepng.h where needed, and your program can read/write PNG files.
+
+If performance is important, use optimization when compiling! For both the
+encoder and decoder, this makes a large difference.
+
+Make sure that LodePNG is compiled with the same compiler of the same version
+and with the same settings as the rest of the program, or the interfaces with
+std::vectors and std::strings in C++ can be incompatible.
+
+CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets.
+
+*) gcc and g++
+
+LodePNG is developed in gcc so this compiler is natively supported. It gives no
+warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++
+version 4.7.1 on Linux, 32-bit and 64-bit.
+
+*) Mingw
+
+The Mingw compiler (a port of gcc) for Windows is fully supported by LodePNG.
+
+*) Visual Studio 2005 and up, Visual C++ Express Edition 2005 and up
+
+Visual Studio may give warnings about 'fopen' being deprecated. A multiplatform library
+can't support the proposed Visual Studio alternative however, so LodePNG keeps using
+fopen. If you don't want to see the deprecated warnings, put this on top of lodepng.h
+before the inclusions:
+#define _CRT_SECURE_NO_DEPRECATE
+
+With warning level 4 (W4), there may be a lot of warnings about possible loss of data
+due to integer conversions. I'm not planning to resolve these warnings. The gcc compiler
+doesn't give those even with strict warning flags. With warning level 3 in VS 2008
+Express Edition, LodePNG is, other than the fopen warnings, warning-free again since
+version 20120923.
+
+Visual Studio may want "stdafx.h" files to be included in each source file. That
+is not standard C++ and will not be added to the stock LodePNG. Try to find a
+setting to disable it for this source file.
+
+*) Visual Studio 6.0
+
+LodePNG support for Visual Studio 6.0 is not guaranteed because VS6 doesn't
+follow the C++ standard correctly.
+
+*) Comeau C/C++
+
+Vesion 20070107 compiles without problems on the Comeau C/C++ Online Test Drive
+at http://www.comeaucomputing.com/tryitout in both C90 and C++ mode.
+
+*) Compilers on Macintosh
+
+LodePNG has been reported to work both with the gcc and LLVM for Macintosh, both
+for C and C++.
+
+*) Other Compilers
+
+If you encounter problems on other compilers, feel free to let me know and I may
+try to fix it if the compiler is modern standards complient.
+
+
+10. examples
+------------
+
+This decoder example shows the most basic usage of LodePNG. More complex
+examples can be found on the LodePNG website.
+
+10.1. decoder C++ example
+-------------------------
+
+#include "lodepng.h"
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+  const char* filename = argc > 1 ? argv[1] : "test.png";
+
+  //load and decode
+  std::vector<unsigned char> image;
+  unsigned width, height;
+  unsigned error = lodepng::decode(image, width, height, filename);
+
+  //if there's an error, display it
+  if(error) std::cout << "decoder error " << error << ": " << lodepng_error_text(error) << std::endl;
+
+  //the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ...
+}
+
+10.2. decoder C example
+-----------------------
+
+#include "lodepng.h"
+
+int main(int argc, char *argv[])
+{
+  unsigned error;
+  unsigned char* image;
+  size_t width, height;
+  const char* filename = argc > 1 ? argv[1] : "test.png";
+
+  error = lodepng_decode32_file(&image, &width, &height, filename);
+
+  if(error) printf("decoder error %u: %s\n", error, lodepng_error_text(error));
+
+  / * use image here * /
+
+  free(image);
+  return 0;
+}
+
+
+11. changes
+-----------
+
+The version number of LodePNG is the date of the change given in the format
+yyyymmdd.
+
+Some changes aren't backwards compatible. Those are indicated with a (!)
+symbol.
+
+*) 28 jan 2013: Bugfix with color key.
+*) 27 okt 2012: Tweaks in text chunk keyword length error handling.
+*) 8 okt 2012 (!): Added new filter strategy (entropy) and new auto color mode.
+    (no palette). Better deflate tree encoding. New compression tweak settings.
+    Faster color conversions while decoding. Some internal cleanups.
+*) 23 sep 2012: Reduced warnings in Visual Studio a little bit.
+*) 1 sep 2012 (!): Removed #define's for giving custom (de)compression functions
+    and made it work with function pointers instead.
+*) 23 jun 2012: Added more filter strategies. Made it easier to use custom alloc
+    and free functions and toggle #defines from compiler flags. Small fixes.
+*) 6 may 2012 (!): Made plugging in custom zlib/deflate functions more flexible.
+*) 22 apr 2012 (!): Made interface more consistent, renaming a lot. Removed
+    redundant C++ codec classes. Reduced amount of structs. Everything changed,
+    but it is cleaner now imho and functionality remains the same. Also fixed
+    several bugs and shrinked the implementation code. Made new samples.
+*) 6 nov 2011 (!): By default, the encoder now automatically chooses the best
+    PNG color model and bit depth, based on the amount and type of colors of the
+    raw image. For this, autoLeaveOutAlphaChannel replaced by auto_choose_color.
+*) 9 okt 2011: simpler hash chain implementation for the encoder.
+*) 8 sep 2011: lz77 encoder lazy matching instead of greedy matching.
+*) 23 aug 2011: tweaked the zlib compression parameters after benchmarking.
+    A bug with the PNG filtertype heuristic was fixed, so that it chooses much
+    better ones (it's quite significant). A setting to do an experimental, slow,
+    brute force search for PNG filter types is added.
+*) 17 aug 2011 (!): changed some C zlib related function names.
+*) 16 aug 2011: made the code less wide (max 120 characters per line).
+*) 17 apr 2011: code cleanup. Bugfixes. Convert low to 16-bit per sample colors.
+*) 21 feb 2011: fixed compiling for C90. Fixed compiling with sections disabled.
+*) 11 dec 2010: encoding is made faster, based on suggestion by Peter Eastman
+    to optimize long sequences of zeros.
+*) 13 nov 2010: added LodePNG_InfoColor_hasPaletteAlpha and
+    LodePNG_InfoColor_canHaveAlpha functions for convenience.
+*) 7 nov 2010: added LodePNG_error_text function to get error code description.
+*) 30 okt 2010: made decoding slightly faster
+*) 26 okt 2010: (!) changed some C function and struct names (more consistent).
+     Reorganized the documentation and the declaration order in the header.
+*) 08 aug 2010: only changed some comments and external samples.
+*) 05 jul 2010: fixed bug thanks to warnings in the new gcc version.
+*) 14 mar 2010: fixed bug where too much memory was allocated for char buffers.
+*) 02 sep 2008: fixed bug where it could create empty tree that linux apps could
+    read by ignoring the problem but windows apps couldn't.
+*) 06 jun 2008: added more error checks for out of memory cases.
+*) 26 apr 2008: added a few more checks here and there to ensure more safety.
+*) 06 mar 2008: crash with encoding of strings fixed
+*) 02 feb 2008: support for international text chunks added (iTXt)
+*) 23 jan 2008: small cleanups, and #defines to divide code in sections
+*) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor.
+*) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder.
+*) 17 jan 2008: ability to encode and decode compressed zTXt chunks added
+    Also vareous fixes, such as in the deflate and the padding bits code.
+*) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved
+    filtering code of encoder.
+*) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A
+    C++ wrapper around this provides an interface almost identical to before.
+    Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code
+    are together in these files but it works both for C and C++ compilers.
+*) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks
+*) 30 aug 2007: bug fixed which makes this Borland C++ compatible
+*) 09 aug 2007: some VS2005 warnings removed again
+*) 21 jul 2007: deflate code placed in new namespace separate from zlib code
+*) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images
+*) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing
+    invalid std::vector element [0] fixed, and level 3 and 4 warnings removed
+*) 02 jun 2007: made the encoder add a tag with version by default
+*) 27 may 2007: zlib and png code separated (but still in the same file),
+    simple encoder/decoder functions added for more simple usage cases
+*) 19 may 2007: minor fixes, some code cleaning, new error added (error 69),
+    moved some examples from here to lodepng_examples.cpp
+*) 12 may 2007: palette decoding bug fixed
+*) 24 apr 2007: changed the license from BSD to the zlib license
+*) 11 mar 2007: very simple addition: ability to encode bKGD chunks.
+*) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding
+    palettized PNG images. Plus little interface change with palette and texts.
+*) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes.
+    Fixed a bug where the end code of a block had length 0 in the Huffman tree.
+*) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented
+    and supported by the encoder, resulting in smaller PNGs at the output.
+*) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone.
+*) 24 jan 2007: gave encoder an error interface. Added color conversion from any
+    greyscale type to 8-bit greyscale with or without alpha.
+*) 21 jan 2007: (!) Totally changed the interface. It allows more color types
+    to convert to and is more uniform. See the manual for how it works now.
+*) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days:
+    encode/decode custom tEXt chunks, separate classes for zlib & deflate, and
+    at last made the decoder give errors for incorrect Adler32 or Crc.
+*) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel.
+*) 29 dec 2006: Added support for encoding images without alpha channel, and
+    cleaned out code as well as making certain parts faster.
+*) 28 dec 2006: Added "Settings" to the encoder.
+*) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now.
+    Removed some code duplication in the decoder. Fixed little bug in an example.
+*) 09 dec 2006: (!) Placed output parameters of public functions as first parameter.
+    Fixed a bug of the decoder with 16-bit per color.
+*) 15 okt 2006: Changed documentation structure
+*) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the
+    given image buffer, however for now it's not compressed.
+*) 08 sep 2006: (!) Changed to interface with a Decoder class
+*) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different
+    way. Renamed decodePNG to decodePNGGeneric.
+*) 29 jul 2006: (!) Changed the interface: image info is now returned as a
+    struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy.
+*) 28 jul 2006: Cleaned the code and added new error checks.
+    Corrected terminology "deflate" into "inflate".
+*) 23 jun 2006: Added SDL example in the documentation in the header, this
+    example allows easy debugging by displaying the PNG and its transparency.
+*) 22 jun 2006: (!) Changed way to obtain error value. Added
+    loadFile function for convenience. Made decodePNG32 faster.
+*) 21 jun 2006: (!) Changed type of info vector to unsigned.
+    Changed position of palette in info vector. Fixed an important bug that
+    happened on PNGs with an uncompressed block.
+*) 16 jun 2006: Internally changed unsigned into unsigned where
+    needed, and performed some optimizations.
+*) 07 jun 2006: (!) Renamed functions to decodePNG and placed them
+    in LodePNG namespace. Changed the order of the parameters. Rewrote the
+    documentation in the header. Renamed files to lodepng.cpp and lodepng.h
+*) 22 apr 2006: Optimized and improved some code
+*) 07 sep 2005: (!) Changed to std::vector interface
+*) 12 aug 2005: Initial release (C++, decoder only)
+
+
+12. contact information
+-----------------------
+
+Feel free to contact me with suggestions, problems, comments, ... concerning
+LodePNG. If you encounter a PNG image that doesn't work properly with this
+decoder, feel free to send it and I'll use it to find and fix the problem.
+
+My email address is (puzzle the account and domain together with an @ symbol):
+Domain: gmail dot com.
+Account: lode dot vandevenne.
+
+
+Copyright (c) 2005-2012 Lode Vandevenne
+*/
diff --git a/src/mainwin.cc b/src/mainwin.cc
index 17b9ef7..dd855fb 100644
--- a/src/mainwin.cc
+++ b/src/mainwin.cc
@@ -48,6 +48,11 @@
 #include "ProgressWidget.h"
 #include "ThrownTogetherRenderer.h"
 #include "csgtermnormalizer.h"
+#include "QGLView.h"
+#include "AutoUpdater.h"
+#ifdef Q_OS_MAC
+#include "CocoaUtils.h"
+#endif
 
 #include <QMenu>
 #include <QTime>
@@ -190,8 +195,8 @@ MainWindow::MainWindow(const QString &filename)
 	editor->setTabStopWidth(30);
 	editor->setLineWrapping(true); // Not designable
 
-	this->glview->statusLabel = new QLabel(this);
-	statusBar()->addWidget(this->glview->statusLabel);
+	this->qglview->statusLabel = new QLabel(this);
+	statusBar()->addWidget(this->qglview->statusLabel);
 
 	animate_timer = new QTimer(this);
 	connect(animate_timer, SIGNAL(timeout()), this, SLOT(updateTVal()));
@@ -205,6 +210,16 @@ MainWindow::MainWindow(const QString &filename)
 
 	animate_panel->hide();
 
+	// Application menu
+#ifdef DEBUG
+	this->appActionUpdateCheck->setEnabled(false);
+#else
+#ifdef Q_OS_MAC
+	this->appActionUpdateCheck->setMenuRole(QAction::ApplicationSpecificRole);
+	this->appActionUpdateCheck->setEnabled(true);
+	connect(this->appActionUpdateCheck, SIGNAL(triggered()), this, SLOT(actionUpdateCheck()));
+#endif
+#endif
 	// File menu
 	connect(this->fileActionNew, SIGNAL(triggered()), this, SLOT(actionNew()));
 	connect(this->fileActionOpen, SIGNAL(triggered()), this, SLOT(actionOpen()));
@@ -291,7 +306,7 @@ MainWindow::MainWindow(const QString &filename)
 	this->viewActionOpenCSG->setVisible(false);
 #else
 	connect(this->viewActionOpenCSG, SIGNAL(triggered()), this, SLOT(viewModeOpenCSG()));
-	if (!this->glview->hasOpenCSGSupport()) {
+	if (!this->qglview->hasOpenCSGSupport()) {
 		this->viewActionOpenCSG->setEnabled(false);
 	}
 #endif
@@ -343,9 +358,9 @@ MainWindow::MainWindow(const QString &filename)
 	connect(editor->document(), SIGNAL(contentsChanged()), this, SLOT(animateUpdateDocChanged()));
 	connect(editor->document(), SIGNAL(modificationChanged(bool)), this, SLOT(setWindowModified(bool)));
 	connect(editor->document(), SIGNAL(modificationChanged(bool)), fileActionSave, SLOT(setEnabled(bool)));
-	connect(this->glview, SIGNAL(doAnimateUpdate()), this, SLOT(animateUpdate()));
+	connect(this->qglview, SIGNAL(doAnimateUpdate()), this, SLOT(animateUpdate()));
 
-	connect(Preferences::inst(), SIGNAL(requestRedraw()), this->glview, SLOT(updateGL()));
+	connect(Preferences::inst(), SIGNAL(requestRedraw()), this->qglview, SLOT(updateGL()));
 	connect(Preferences::inst(), SIGNAL(fontChanged(const QString&,uint)), 
 					this, SLOT(setFont(const QString&,uint)));
 	connect(Preferences::inst(), SIGNAL(openCSGSettingsChanged()),
@@ -507,7 +522,7 @@ MainWindow::setFileName(const QString &filename)
 			this->fileName = fileinfo.fileName();
 		}
 		
-		this->root_ctx.setDocumentPath(fileinfo.dir().absolutePath().toStdString());
+		this->root_ctx.setDocumentPath(fileinfo.dir().absolutePath().toLocal8Bit().constData());
 		QDir::setCurrent(fileinfo.dir().absolutePath());
 	}
 
@@ -571,28 +586,19 @@ void MainWindow::refreshDocument()
 		QFile file(this->fileName);
 		if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 			PRINTB("Failed to open file %s: %s", 
-						 this->fileName.toStdString() % file.errorString().toStdString());
+						 this->fileName.toLocal8Bit().constData() % file.errorString().toLocal8Bit().constData());
 		}
 		else {
 			QTextStream reader(&file);
 			reader.setCodec("UTF-8");
 			QString text = reader.readAll();
-			PRINTB("Loaded design '%s'.", this->fileName.toStdString());
+			PRINTB("Loaded design '%s'.", this->fileName.toLocal8Bit().constData());
 			editor->setPlainText(text);
 		}
 	}
 	setCurrentOutput();
 }
 
-AbstractNode *MainWindow::find_root_tag(AbstractNode *n)
-{
-	BOOST_FOREACH (AbstractNode *v, n->children) {
-		if (v->modinst->isRoot()) return v;
-		if (AbstractNode *vroot = find_root_tag(v)) return vroot;
-	}
-	return NULL;
-}
-
 /*!
 	Parse and evaluate the design => this->root_node
 
@@ -604,7 +610,7 @@ bool MainWindow::compile(bool reload, bool procevents)
 	if (!compileTopLevelDocument(reload)) return false;
 
   // Invalidate renderers before we kill the CSG tree
-	this->glview->setRenderer(NULL);
+	this->qglview->setRenderer(NULL);
 	delete this->opencsgRenderer;
 	this->opencsgRenderer = NULL;
 	delete this->thrownTogetherRenderer;
@@ -768,7 +774,7 @@ void MainWindow::compileCSG(bool procevents)
 			this->opencsgRenderer = new OpenCSGRenderer(this->root_chain, 
 																									this->highlights_chain, 
 																									this->background_chain, 
-																									this->glview->shaderinfo);
+																									this->qglview->shaderinfo);
 		}
 		this->thrownTogetherRenderer = new ThrownTogetherRenderer(this->root_chain, 
 																															this->highlights_chain, 
@@ -781,6 +787,13 @@ void MainWindow::compileCSG(bool procevents)
 	}
 }
 
+void MainWindow::actionUpdateCheck()
+{
+	if (AutoUpdater *updater =AutoUpdater::updater()) {
+		updater->checkForUpdates();
+	}
+}
+
 void MainWindow::actionNew()
 {
 #ifdef ENABLE_MDI
@@ -891,13 +904,13 @@ void MainWindow::actionSave()
 		setCurrentOutput();
 		QFile file(this->fileName);
 		if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) {
-			PRINTB("Failed to open file for writing: %s (%s)", this->fileName.toStdString() % file.errorString().toStdString());
+			PRINTB("Failed to open file for writing: %s (%s)", this->fileName.toLocal8Bit().constData() % file.errorString().toLocal8Bit().constData());
 		}
 		else {
 			QTextStream writer(&file);
 			writer.setCodec("UTF-8");
 			writer << this->editor->toPlainText();
-			PRINTB("Saved design '%s'.", this->fileName.toStdString());
+			PRINTB("Saved design '%s'.", this->fileName.toLocal8Bit().constData());
 			this->editor->setContentModified(false);
 		}
 		clearCurrentOutput();
@@ -951,7 +964,7 @@ void MainWindow::pasteViewportTranslation()
 {
 	QTextCursor cursor = editor->textCursor();
 	QString txt;
-	txt.sprintf("[ %.2f, %.2f, %.2f ]", -this->glview->object_trans_x, -this->glview->object_trans_y, -this->glview->object_trans_z);
+	txt.sprintf("[ %.2f, %.2f, %.2f ]", -qglview->cam.object_trans.x(), -qglview->cam.object_trans.y(), -qglview->cam.object_trans.z());
 	cursor.insertText(txt);
 }
 
@@ -960,7 +973,7 @@ void MainWindow::pasteViewportRotation()
 	QTextCursor cursor = editor->textCursor();
 	QString txt;
 	txt.sprintf("[ %.2f, %.2f, %.2f ]",
-		fmodf(360 - this->glview->object_rot_x + 90, 360), fmodf(360 - this->glview->object_rot_y, 360), fmodf(360 - this->glview->object_rot_z, 360));
+		fmodf(360 - qglview->cam.object_rot.x() + 90, 360), fmodf(360 - qglview->cam.object_rot.y(), 360), fmodf(360 - qglview->cam.object_rot.z(), 360));
 	cursor.insertText(txt);
 }
 
@@ -969,15 +982,15 @@ void MainWindow::updateTemporalVariables()
 	this->root_ctx.set_variable("$t", Value(this->e_tval->text().toDouble()));
 	
 	Value::VectorType vpt;
-	vpt.push_back(Value(-this->glview->object_trans_x));
-	vpt.push_back(Value(-this->glview->object_trans_y));
-	vpt.push_back(Value(-this->glview->object_trans_z));
+	vpt.push_back(Value(-qglview->cam.object_trans.x()));
+	vpt.push_back(Value(-qglview->cam.object_trans.y()));
+	vpt.push_back(Value(-qglview->cam.object_trans.z()));
 	this->root_ctx.set_variable("$vpt", Value(vpt));
 	
 	Value::VectorType vpr;
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_x + 90, 360)));
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_y, 360)));
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_z, 360)));
+	vpr.push_back(Value(fmodf(360 - qglview->cam.object_rot.x() + 90, 360)));
+	vpr.push_back(Value(fmodf(360 - qglview->cam.object_rot.y(), 360)));
+	vpr.push_back(Value(fmodf(360 - qglview->cam.object_rot.z(), 360)));
 	root_ctx.set_variable("$vpr", Value(vpr));
 }
 
@@ -1027,8 +1040,9 @@ bool MainWindow::compileTopLevelDocument(bool reload)
 {
 	bool shouldcompiletoplevel = !reload;
 
-	if ((reload && fileChangedOnDisk() && checkEditorModified()) ||
-			includesChanged()) {
+	if (includesChanged()) shouldcompiletoplevel = true;
+
+	if (reload && fileChangedOnDisk() && checkEditorModified()) {
 		shouldcompiletoplevel = true;
 		refreshDocument();
 	}
@@ -1040,7 +1054,8 @@ bool MainWindow::compileTopLevelDocument(bool reload)
 		
 		this->last_compiled_doc = editor->toPlainText();
 		std::string fulltext = 
-			this->last_compiled_doc.toStdString() + "\n" + commandline_commands;
+			std::string(this->last_compiled_doc.toLocal8Bit().constData()) +
+			"\n" + commandline_commands;
 		
 		delete this->root_module;
 		this->root_module = NULL;
@@ -1156,7 +1171,7 @@ void MainWindow::actionCompile()
 	}
 
 	if (viewActionAnimate->isChecked() && e_dump->isChecked()) {
-		QImage img = this->glview->grabFrameBuffer();
+		QImage img = this->qglview->grabFrameBuffer();
 		QString filename;
 		double s = this->e_fsteps->text().toDouble();
 		double t = this->e_tval->text().toDouble();
@@ -1185,7 +1200,7 @@ void MainWindow::actionRenderCGAL()
 		return;
 	}
 
-	this->glview->setRenderer(NULL);
+	this->qglview->setRenderer(NULL);
 	delete this->cgalRenderer;
 	this->cgalRenderer = NULL;
 	if (this->root_N) {
@@ -1279,7 +1294,7 @@ void MainWindow::actionDisplayAST()
 	e->setWindowTitle("AST Dump");
 	e->setReadOnly(true);
 	if (root_module) {
-		e->setPlainText(QString::fromStdString(root_module->dump("", "")));
+		e->setPlainText(QString::fromLocal8Bit(root_module->dump("", "").c_str()));
 	} else {
 		e->setPlainText("No AST to dump. Please try compiling first...");
 	}
@@ -1297,7 +1312,7 @@ void MainWindow::actionDisplayCSGTree()
 	e->setWindowTitle("CSG Tree Dump");
 	e->setReadOnly(true);
 	if (this->root_node) {
-		e->setPlainText(QString::fromStdString(this->tree.getString(*this->root_node)));
+		e->setPlainText(QString::fromLocal8Bit(this->tree.getString(*this->root_node).c_str()));
 	} else {
 		e->setPlainText("No CSG to dump. Please try compiling first...");
 	}
@@ -1314,7 +1329,12 @@ void MainWindow::actionDisplayCSGProducts()
 	e->setTabStopWidth(30);
 	e->setWindowTitle("CSG Products Dump");
 	e->setReadOnly(true);
-	e->setPlainText(QString("\nCSG before normalization:\n%1\n\n\nCSG after normalization:\n%2\n\n\nCSG rendering chain:\n%3\n\n\nHighlights CSG rendering chain:\n%4\n\n\nBackground CSG rendering chain:\n%5\n").arg(root_raw_term ? QString::fromStdString(root_raw_term->dump()) : "N/A", root_norm_term ? QString::fromStdString(root_norm_term->dump()) : "N/A", this->root_chain ? QString::fromStdString(this->root_chain->dump()) : "N/A", highlights_chain ? QString::fromStdString(highlights_chain->dump()) : "N/A", background_chain ? QString::fromStdString(background_chain->dump()) : "N/A"));
+	e->setPlainText(QString("\nCSG before normalization:\n%1\n\n\nCSG after normalization:\n%2\n\n\nCSG rendering chain:\n%3\n\n\nHighlights CSG rendering chain:\n%4\n\n\nBackground CSG rendering chain:\n%5\n")
+									.arg(root_raw_term ? QString::fromLocal8Bit(root_raw_term->dump().c_str()) : "N/A", 
+											 root_norm_term ? QString::fromLocal8Bit(root_norm_term->dump().c_str()) : "N/A", 
+											 this->root_chain ? QString::fromLocal8Bit(this->root_chain->dump().c_str()) : "N/A", 
+											 highlights_chain ? QString::fromLocal8Bit(highlights_chain->dump().c_str()) : "N/A", 
+											 background_chain ? QString::fromLocal8Bit(background_chain->dump().c_str()) : "N/A"));
 	e->show();
 	e->resize(600, 400);
 	clearCurrentOutput();
@@ -1362,7 +1382,7 @@ void MainWindow::actionExportSTLorOFF(bool)
 
 	std::ofstream fstream(stl_filename.toUtf8());
 	if (!fstream.is_open()) {
-		PRINTB("Can't open file \"%s\" for export", stl_filename.toStdString());
+		PRINTB("Can't open file \"%s\" for export", stl_filename.toLocal8Bit().constData());
 	}
 	else {
 		if (stl_mode) export_stl(this->root_N, fstream);
@@ -1415,7 +1435,7 @@ void MainWindow::actionExportDXF()
 
 	std::ofstream fstream(dxf_filename.toUtf8());
 	if (!fstream.is_open()) {
-		PRINTB("Can't open file \"%s\" for export", dxf_filename.toStdString());
+		PRINTB("Can't open file \"%s\" for export", dxf_filename.toLocal8Bit().constData());
 	}
 	else {
 		export_dxf(this->root_N, fstream);
@@ -1448,7 +1468,7 @@ void MainWindow::actionExportCSG()
 
 	std::ofstream fstream(csg_filename.toUtf8());
 	if (!fstream.is_open()) {
-		PRINTB("Can't open file \"%s\" for export", csg_filename.toStdString());
+		PRINTB("Can't open file \"%s\" for export", csg_filename.toLocal8Bit().constData());
 	}
 	else {
 		fstream << this->tree.getString(*this->root_node) << "\n";
@@ -1461,20 +1481,17 @@ void MainWindow::actionExportCSG()
 
 void MainWindow::actionExportImage()
 {
-	QImage img = this->glview->grabFrameBuffer();
 	setCurrentOutput();
 
 	QString img_filename = QFileDialog::getSaveFileName(this,
 			"Export Image", "", "PNG Files (*.png)");
 	if (img_filename.isEmpty()) {
 		PRINT("No filename specified. Image export aborted.");
-		clearCurrentOutput();
-		return;
+	} else {
+		qglview->save(img_filename.toLocal8Bit().constData());
 	}
-
-	img.save(img_filename, "PNG");
-
 	clearCurrentOutput();
+	return;
 }
 
 void MainWindow::actionFlushCaches()
@@ -1506,10 +1523,11 @@ void MainWindow::viewModeActionsUncheck()
 */
 void MainWindow::viewModeOpenCSG()
 {
-	if (this->glview->hasOpenCSGSupport()) {
+	if (this->qglview->hasOpenCSGSupport()) {
 		viewModeActionsUncheck();
 		viewActionOpenCSG->setChecked(true);
-		this->glview->setRenderer(this->opencsgRenderer ? (Renderer *)this->opencsgRenderer : (Renderer *)this->thrownTogetherRenderer);
+		this->qglview->setRenderer(this->opencsgRenderer ? (Renderer *)this->opencsgRenderer : (Renderer *)this->thrownTogetherRenderer);
+		this->qglview->updateGL();
 	} else {
 		viewModeThrownTogether();
 	}
@@ -1523,17 +1541,18 @@ void MainWindow::viewModeCGALSurface()
 {
 	viewModeActionsUncheck();
 	viewActionCGALSurfaces->setChecked(true);
-	this->glview->setShowFaces(true);
-	this->glview->setRenderer(this->cgalRenderer);
-	this->glview->updateGL();
+	this->qglview->setShowFaces(true);
+	this->qglview->setRenderer(this->cgalRenderer);
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeCGALGrid()
 {
 	viewModeActionsUncheck();
 	viewActionCGALGrid->setChecked(true);
-	this->glview->setShowFaces(false);
-	this->glview->setRenderer(this->cgalRenderer);
+	this->qglview->setShowFaces(false);
+	this->qglview->setRenderer(this->cgalRenderer);
+	this->qglview->updateGL();
 }
 
 #endif /* ENABLE_CGAL */
@@ -1542,31 +1561,32 @@ void MainWindow::viewModeThrownTogether()
 {
 	viewModeActionsUncheck();
 	viewActionThrownTogether->setChecked(true);
-	this->glview->setRenderer(this->thrownTogetherRenderer);
+	this->qglview->setRenderer(this->thrownTogetherRenderer);
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeShowEdges()
 {
 	QSettings settings;
 	settings.setValue("view/showEdges",viewActionShowEdges->isChecked());
-	this->glview->setShowEdges(viewActionShowEdges->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowEdges(viewActionShowEdges->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeShowAxes()
 {
 	QSettings settings;
 	settings.setValue("view/showAxes",viewActionShowAxes->isChecked());
-	this->glview->setShowAxes(viewActionShowAxes->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowAxes(viewActionShowAxes->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeShowCrosshairs()
 {
 	QSettings settings;
 	settings.setValue("view/showCrosshairs",viewActionShowCrosshairs->isChecked());
-	this->glview->setShowCrosshairs(viewActionShowCrosshairs->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowCrosshairs(viewActionShowCrosshairs->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeAnimate()
@@ -1604,66 +1624,50 @@ void MainWindow::animateUpdate()
 
 void MainWindow::viewAngleTop()
 {
-	this->glview->object_rot_x = 90;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 90,0,0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleBottom()
 {
-	this->glview->object_rot_x = 270;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 270,0,0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleLeft()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 90;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 0,0,90;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleRight()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 270;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 0,0,270;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleFront()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 0,0,0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleBack()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 180;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 0,0,180;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleDiagonal()
 {
-	this->glview->object_rot_x = 35;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = -25;
-	this->glview->updateGL();
+	qglview->cam.object_rot << 35,0,-25;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewCenter()
 {
-	this->glview->object_trans_x = 0;
-	this->glview->object_trans_y = 0;
-	this->glview->object_trans_z = 0;
-	this->glview->updateGL();
+	qglview->cam.object_trans << 0,0,0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewPerspective()
@@ -1672,8 +1676,8 @@ void MainWindow::viewPerspective()
 	settings.setValue("view/orthogonalProjection",false);
 	viewActionPerspective->setChecked(true);
 	viewActionOrthogonal->setChecked(false);
-	this->glview->setOrthoMode(false);
-	this->glview->updateGL();
+	this->qglview->setOrthoMode(false);
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewOrthogonal()
@@ -1682,8 +1686,8 @@ void MainWindow::viewOrthogonal()
 	settings.setValue("view/orthogonalProjection",true);
 	viewActionPerspective->setChecked(false);
 	viewActionOrthogonal->setChecked(true);
-	this->glview->setOrthoMode(true);
-	this->glview->updateGL();
+	this->qglview->setOrthoMode(true);
+	this->qglview->updateGL();
 }
 
 void MainWindow::hideConsole()
@@ -1754,13 +1758,11 @@ void MainWindow::helpLibrary()
 									qVersion());
 
 	if (!this->openglbox) {
-		this->openglbox = new QMessageBox(QMessageBox::Information, 
-																			"OpenGL Info", "Detailed Library Info",
-																			QMessageBox::Ok, this);
-		
+    this->openglbox = new QMessageBox(QMessageBox::Information, 
+                                      "OpenGL Info", "OpenSCAD Detailed Library Info                  ",
+                                      QMessageBox::Ok, this);
 	}
-
-	this->openglbox->setDetailedText(libinfo + this->glview->getRendererInfo());
+  this->openglbox->setDetailedText(libinfo + QString(qglview->getRendererInfo().c_str()));
 	this->openglbox->show();
 }
 
@@ -1825,6 +1827,9 @@ void MainWindow::quit()
 	QApplication::sendEvent(QApplication::instance(), &ev);
 	if (ev.isAccepted()) QApplication::instance()->quit();
   // FIXME: Cancel any CGAL calculations
+#ifdef Q_OS_MAC
+	CocoaUtils::endApplication();
+#endif
 }
 
 void MainWindow::consoleOutput(const std::string &msg, void *userdata)
@@ -1833,7 +1838,7 @@ void MainWindow::consoleOutput(const std::string &msg, void *userdata)
   // originates in a worker thread.
 	MainWindow *thisp = static_cast<MainWindow*>(userdata);
 	QMetaObject::invokeMethod(thisp->console, "append", Qt::QueuedConnection,
-														 Q_ARG(QString, QString::fromStdString(msg)));
+														Q_ARG(QString, QString::fromLocal8Bit(msg.c_str())));
 }
 
 void MainWindow::setCurrentOutput()
diff --git a/src/module.cc b/src/module.cc
index cfd73cc..e6dcb57 100644
--- a/src/module.cc
+++ b/src/module.cc
@@ -136,7 +136,7 @@ std::vector<AbstractNode*> IfElseModuleInstantiation::evaluateElseChildren(const
 
 Module::~Module()
 {
-	BOOST_FOREACH (Expression *v, assignments_expr) delete v;
+	BOOST_FOREACH (const AssignmentContainer::value_type &v, assignments) delete v.second;
 	BOOST_FOREACH (FunctionContainer::value_type &f, functions) delete f.second;
 	BOOST_FOREACH (AbstractModuleContainer::value_type &m, modules) delete m.second;
 	BOOST_FOREACH (ModuleInstantiation *v, children) delete v;
@@ -158,8 +158,8 @@ AbstractNode *Module::evaluate(const Context *ctx, const ModuleInstantiation *in
 	else
 		c.usedlibs_p = NULL;
 
-	for (size_t i = 0; i < assignments_var.size(); i++) {
-		c.set_variable(assignments_var[i], assignments_expr[i]->evaluate(&c));
+	BOOST_FOREACH(const std::string &var, assignments_var) {
+		c.set_variable(var, assignments.at(var)->evaluate(&c));
 	}
 
 	AbstractNode *node = new AbstractNode(inst);
@@ -192,8 +192,8 @@ std::string Module::dump(const std::string &indent, const std::string &name) con
 	BOOST_FOREACH(const AbstractModuleContainer::value_type &m, modules) {
 		dump << m.second->dump(indent + tab, m.first);
 	}
-	for (size_t i = 0; i < assignments_var.size(); i++) {
-		dump << indent << tab << assignments_var[i] << " = " << *assignments_expr[i] << ";\n";
+	BOOST_FOREACH(const std::string &var, assignments_var) {
+		dump << indent << tab << var << " = " << *assignments.at(var) << ";\n";
 	}
 	for (size_t i = 0; i < children.size(); i++) {
 		dump << children[i]->dump(indent + tab);
diff --git a/src/module.h b/src/module.h
index 879d249..cc82f81 100644
--- a/src/module.h
+++ b/src/module.h
@@ -74,8 +74,9 @@ public:
 	bool is_handling_dependencies;
 	bool handleDependencies();
 
-	std::vector<std::string> assignments_var;
-	std::vector<Expression*> assignments_expr;
+	std::list<std::string> assignments_var;
+	typedef boost::unordered_map<std::string, Expression*> AssignmentContainer;
+	AssignmentContainer assignments;
 
 	typedef boost::unordered_map<std::string, class AbstractFunction*> FunctionContainer;
 	FunctionContainer functions;
diff --git a/src/node.cc b/src/node.cc
index e61174f..a7a7630 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -32,6 +32,7 @@
 
 #include <iostream>
 #include <algorithm>
+#include <boost/foreach.hpp>
 
 size_t AbstractNode::idx_counter;
 
@@ -101,3 +102,14 @@ std::ostream &operator<<(std::ostream &stream, const AbstractNode &node)
 	stream << node.toString();
 	return stream;
 }
+
+// Do we have an explicit root node (! modifier)?
+AbstractNode *find_root_tag(AbstractNode *n)
+{
+  BOOST_FOREACH(AbstractNode *v, n->children) {
+    if (v->modinst->tag_root) return v;
+    if (AbstractNode *vroot = find_root_tag(v)) return vroot;
+  }
+  return NULL;
+}
+
diff --git a/src/node.h b/src/node.h
index 42547db..0b2221d 100644
--- a/src/node.h
+++ b/src/node.h
@@ -84,5 +84,6 @@ public:
 };
 
 std::ostream &operator<<(std::ostream &stream, const AbstractNode &node);
+AbstractNode *find_root_tag(AbstractNode *n);
 
 #endif
diff --git a/src/openscad.cc b/src/openscad.cc
index 880aa0d..f7cc48e 100644
--- a/src/openscad.cc
+++ b/src/openscad.cc
@@ -36,6 +36,7 @@
 #include "printutils.h"
 #include "handle_dep.h"
 #include "parsersettings.h"
+#include "rendersettings.h"
 
 #include <string>
 #include <vector>
@@ -48,14 +49,20 @@
 #endif
 
 #include <QApplication>
+#include <QString>
 #include <QDir>
 #include <sstream>
 
 #ifdef Q_WS_MAC
 #include "EventFilter.h"
 #include "AppleEvents.h"
+#ifdef OPENSCAD_DEPLOY
+  #include "SparkleAutoUpdater.h"
+#endif
 #endif
 
+#include "Camera.h"
+#include <boost/algorithm/string.hpp>
 #include <boost/program_options.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
@@ -70,9 +77,14 @@ namespace fs = boost::filesystem;
 
 static void help(const char *progname)
 {
-	fprintf(stderr, "Usage: %s [ -o output_file [ -d deps_file ] ]\\\n"
-					"%*s[ -m make_command ] [ -D var=val [..] ] filename\n",
-					progname, int(strlen(progname))+8, "");
+	int tab = int(strlen(progname))+8;
+	fprintf(stderr,"Usage: %s [ -o output_file [ -d deps_file ] ]\\\n"
+	        "%*s[ -m make_command ] [ -D var=val [..] ] [ --render ] \\\n"
+	        "%*s[ --camera=translatex,y,z,rotx,y,z,dist | \\\n"
+	        "%*s  --camera=eyex,y,z,centerx,y,z ] \\\n"
+	        "%*s[ --imgsize=width,height ] [ --projection=(o)rtho|(p)ersp] \\\n"
+	        "%*sfilename\n",
+					progname, tab, "", tab, "", tab, "", tab, "", tab, "");
 	exit(1);
 }
 
@@ -90,6 +102,58 @@ QString examplesdir;
 
 using std::string;
 using std::vector;
+using boost::lexical_cast;
+using boost::is_any_of;
+
+Camera get_camera( po::variables_map vm )
+{
+	Camera camera;
+
+	if (vm.count("camera")) {
+		vector<string> strs;
+		vector<double> cam_parameters;
+		split(strs, vm["camera"].as<string>(), is_any_of(","));
+		if ( strs.size() == 6 || strs.size() == 7 ) {
+			BOOST_FOREACH(string &s, strs)
+				cam_parameters.push_back(lexical_cast<double>(s));
+			camera.setup( cam_parameters );
+		} else {
+			fprintf(stderr,"Camera setup requires either 7 numbers for Gimbal Camera\n");
+			fprintf(stderr,"or 6 numbers for Vector Camera\n");
+			exit(1);
+		}
+	}
+
+	if (vm.count("projection")) {
+		string proj = vm["projection"].as<string>();
+		if (proj=="o" || proj=="ortho" || proj=="orthogonal")
+			camera.projection = Camera::ORTHOGONAL;
+		else if (proj=="p" || proj=="perspective")
+			camera.projection = Camera::PERSPECTIVE;
+		else {
+			fprintf(stderr,"projection needs to be 'o' or 'p' for ortho or perspective\n");
+			exit(1);
+		}
+	}
+
+	int w = RenderSettings::inst()->img_width;
+	int h = RenderSettings::inst()->img_height;
+	if (vm.count("imgsize")) {
+		vector<string> strs;
+		split(strs, vm["imgsize"].as<string>(), is_any_of(","));
+		if ( strs.size() != 2 ) {
+			fprintf(stderr,"Need 2 numbers for imgsize\n");
+			exit(1);
+		} else {
+			w = lexical_cast<int>( strs[0] );
+			h = lexical_cast<int>( strs[1] );
+		}
+	}
+	camera.pixel_width = w;
+	camera.pixel_height = h;
+
+	return camera;
+}
 
 int main(int argc, char **argv)
 {
@@ -132,6 +196,10 @@ int main(int argc, char **argv)
 	desc.add_options()
 		("help,h", "help message")
 		("version,v", "print the version")
+		("render", "if exporting a png image, do a full CGAL render")
+		("camera", po::value<string>(), "parameters for camera when exporting png")
+	        ("imgsize", po::value<string>(), "=width,height for exporting png")
+		("projection", po::value<string>(), "(o)rtho or (p)erspective when exporting png")
 		("o,o", po::value<string>(), "out-file")
 		("s,s", po::value<string>(), "stl-file")
 		("x,x", po::value<string>(), "dxf-file")
@@ -206,6 +274,8 @@ int main(int argc, char **argv)
 
 	currentdir = boosty::stringy(fs::current_path());
 
+	Camera camera = get_camera( vm );
+
 	QDir exdir(QApplication::instance()->applicationDirPath());
 #ifdef Q_WS_MAC
 	exdir.cd("../Resources"); // Examples can be bundled
@@ -225,7 +295,7 @@ int main(int argc, char **argv)
 					examplesdir = exdir.path();
 				}
 
-	parser_init(QApplication::instance()->applicationDirPath().toStdString());
+	parser_init(QApplication::instance()->applicationDirPath().toLocal8Bit().constData());
 
 	// Initialize global visitors
 	NodeCache nodecache;
@@ -242,12 +312,14 @@ int main(int argc, char **argv)
 		const char *off_output_file = NULL;
 		const char *dxf_output_file = NULL;
 		const char *csg_output_file = NULL;
+		const char *png_output_file = NULL;
 
 		QString suffix = QFileInfo(output_file).suffix().toLower();
 		if (suffix == "stl") stl_output_file = output_file;
 		else if (suffix == "off") off_output_file = output_file;
 		else if (suffix == "dxf") dxf_output_file = output_file;
 		else if (suffix == "csg") csg_output_file = output_file;
+		else if (suffix == "png") png_output_file = output_file;
 		else {
 			fprintf(stderr, "Unknown suffix for output file %s\n", output_file);
 			exit(1);
@@ -261,6 +333,8 @@ int main(int argc, char **argv)
 		Module *root_module;
 		ModuleInstantiation root_inst;
 		AbstractNode *root_node;
+		AbstractNode *absolute_root_node;
+		CGAL_Nef_polyhedron root_N;
 
 		handle_dep(filename);
 		
@@ -282,7 +356,13 @@ int main(int argc, char **argv)
 		fs::current_path(fparent);
 
 		AbstractNode::resetIndexCounter();
+		absolute_root_node = root_module->evaluate(&root_ctx, &root_inst);
 		root_node = root_module->evaluate(&root_ctx, &root_inst);
+
+		// Do we have an explicit root node (! modifier)?
+		if (!(root_node = find_root_tag(absolute_root_node)))
+	    root_node = absolute_root_node;
+
 		tree.setRoot(root_node);
 
 		if (csg_output_file) {
@@ -299,16 +379,21 @@ int main(int argc, char **argv)
 		}
 		else {
 #ifdef ENABLE_CGAL
-			CGAL_Nef_polyhedron root_N = cgalevaluator.evaluateCGALMesh(*tree.root());
-			
+			if (png_output_file && !vm.count("render")) {
+				// OpenCSG png -> don't necessarily need CGALMesh evaluation
+			} else {
+				root_N = cgalevaluator.evaluateCGALMesh(*tree.root());
+			}
+
 			fs::current_path(original_path);
-			
+
 			if (deps_output_file) {
 				std::string deps_out( deps_output_file );
 				std::string geom_out;
 				if ( stl_output_file ) geom_out = std::string(stl_output_file);
 				else if ( off_output_file ) geom_out = std::string(off_output_file);
 				else if ( dxf_output_file ) geom_out = std::string(dxf_output_file);
+				else if ( png_output_file ) geom_out = std::string(png_output_file);
 				else {
 					PRINTB("Output file:%s\n",output_file);
 					PRINT("Sorry, don't know how to write deps for that file type. Exiting\n");
@@ -373,6 +458,21 @@ int main(int argc, char **argv)
 					fstream.close();
 				}
 			}
+
+			if (png_output_file) {
+				std::ofstream fstream(png_output_file,std::ios::out|std::ios::binary);
+				if (!fstream.is_open()) {
+					PRINTB("Can't open file \"%s\" for export", png_output_file);
+				}
+				else {
+					if (vm.count("render")) {
+						export_png_with_cgal(&root_N, camera, fstream);
+					} else {
+						export_png_with_opencsg(tree, camera, fstream);
+					}
+					fstream.close();
+				}
+			}
 #else
 			fprintf(stderr, "OpenSCAD has been compiled without CGAL support!\n");
 			exit(1);
@@ -386,8 +486,14 @@ int main(int argc, char **argv)
 		installAppleEventHandlers();
 #endif		
 
+#if defined(OPENSCAD_DEPLOY) && defined(Q_WS_MAC)
+		AutoUpdater *updater = new SparkleAutoUpdater;
+		AutoUpdater::setUpdater(updater);
+		if (updater->automaticallyChecksForUpdates()) updater->checkForUpdates();
+#endif
+
 		QString qfilename;
-		if (filename) qfilename = QString::fromStdString(boosty::stringy(boosty::absolute(filename)));
+		if (filename) qfilename = QString::fromLocal8Bit(boosty::stringy(boosty::absolute(filename)).c_str());
 
 #if 0 /*** disabled by clifford wolf: adds rendering artefacts with OpenCSG ***/
 		// turn on anti-aliasing
@@ -402,7 +508,7 @@ int main(int argc, char **argv)
 		if (vm.count("input-file")) {
 			inputFiles = vm["input-file"].as<vector<string> >();
 			for (vector<string>::const_iterator infile = inputFiles.begin()+1; infile != inputFiles.end(); infile++) {
-				new MainWindow(QString::fromStdString(boosty::stringy((original_path / *infile))));
+				new MainWindow(QString::fromLocal8Bit(boosty::stringy(original_path / *infile).c_str()));
 			}
 		}
 		app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
diff --git a/src/parser.y b/src/parser.y
index 3e485ff..536f4ef 100644
--- a/src/parser.y
+++ b/src/parser.y
@@ -151,19 +151,10 @@ statement:
 		}
 	} |
 	TOK_ID '=' expr ';' {
-		bool add_new_assignment = true;
-		for (size_t i = 0; i < currmodule->assignments_var.size(); i++) {
-			if (currmodule->assignments_var[i] != $1)
-				continue;
-			delete currmodule->assignments_expr[i];
-			currmodule->assignments_expr[i] = $3;
-			add_new_assignment = false;
-		}
-		if (add_new_assignment) {
-			currmodule->assignments_var.push_back($1);
-			currmodule->assignments_expr.push_back($3);
-			free($1);
-		}
+          std::list<std::string>::iterator found = std::find(currmodule->assignments_var.begin(), currmodule->assignments_var.end(),$1);
+          if (found != currmodule->assignments_var.end()) currmodule->assignments_var.erase(found);
+          currmodule->assignments_var.push_back($1);
+          currmodule->assignments[$1] = $3;
 	} |
 	TOK_MODULE TOK_ID '(' arguments_decl optional_commas ')' {
 		Module *p = currmodule;
diff --git a/src/parsersettings.cc b/src/parsersettings.cc
index 3dda132..a757ba1 100644
--- a/src/parsersettings.cc
+++ b/src/parsersettings.cc
@@ -2,7 +2,9 @@
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
 #include "boosty.h"
+#include <boost/algorithm/string.hpp>
 #include <qglobal.h> // Needed for Q_ defines - move the offending code somewhere else
+#include "CocoaUtils.h"
 
 namespace fs = boost::filesystem;
 
@@ -28,15 +30,24 @@ std::string locate_file(const std::string &filename)
 
 void parser_init(const std::string &applicationpath)
 {
-  // Add path from OPENSCADPATH before adding built-in paths
-	const char *openscadpath = getenv("OPENSCADPATH");
-	if (openscadpath) {
-		add_librarydir(boosty::absolute(fs::path(openscadpath)).string());
+  // Add paths from OPENSCADPATH before adding built-in paths
+	const char *openscadpaths = getenv("OPENSCADPATH");
+	if (openscadpaths) {
+		std::string paths(openscadpaths);
+    typedef boost::split_iterator<std::string::iterator> string_split_iterator;
+    for (string_split_iterator it =
+					 make_split_iterator(paths, first_finder(":", boost::is_iequal()));
+				 it != string_split_iterator();
+				 ++it) {
+		add_librarydir(boosty::absolute(fs::path(boost::copy_range<std::string>(*it))).string());
+    }
 	}
 
-	// FIXME: Support specifying more than one path in OPENSCADPATH
 	// FIXME: Add ~/.openscad/libraries
-	// FIXME: Add ~/Documents/OpenSCAD/libraries on Mac?
+#if defined(__APPLE__) && !defined(OPENSCAD_TESTING)
+	fs::path docdir(CocoaUtils::documentsPath());
+	add_librarydir(boosty::stringy(docdir / "OpenSCAD" / "libraries"));
+#endif
 
 	std::string librarydir;
 	fs::path libdir(applicationpath);
diff --git a/src/printutils.cc b/src/printutils.cc
index a8b62aa..698fffb 100644
--- a/src/printutils.cc
+++ b/src/printutils.cc
@@ -1,4 +1,5 @@
 #include "printutils.h"
+#include <sstream>
 #include <stdio.h>
 
 std::list<std::string> print_messages_stack;
@@ -49,3 +50,24 @@ void PRINT_NOCACHE(const std::string &msg)
 		outputhandler(msg, outputhandler_data);
 	}
 }
+
+std::string two_digit_exp_format( std::string doublestr )
+{
+#ifdef _WIN32
+	size_t exppos = doublestr.find('e');
+	if ( exppos != std::string::npos) {
+		exppos += 2;
+		if ( doublestr[exppos] == '0' ) doublestr.erase(exppos,1);
+	}
+#endif
+	return doublestr;
+}
+
+std::string two_digit_exp_format( double x )
+{
+	std::stringstream s;
+	s << x;
+	return two_digit_exp_format( s.str() );
+}
+
+
diff --git a/src/printutils.h b/src/printutils.h
index 9d99a19..439c884 100644
--- a/src/printutils.h
+++ b/src/printutils.h
@@ -22,6 +22,9 @@ void PRINT(const std::string &msg);
 void PRINT_NOCACHE(const std::string &msg);
 #define PRINTB_NOCACHE(_fmt, _arg) do { PRINT_NOCACHE(str(boost::format(_fmt) % _arg)); } while (0)
 
+std::string two_digit_exp_format( std::string doublestr );
+std::string two_digit_exp_format( double x );
+
 // extremely simple logging, eventually replace with something like boost.log
 // usage: logstream out(5); openscad_loglevel=6; out << "hi";
 static int openscad_loglevel = 0;
diff --git a/src/rendersettings.cc b/src/rendersettings.cc
index 195f2d8..e9c2f63 100644
--- a/src/rendersettings.cc
+++ b/src/rendersettings.cc
@@ -12,6 +12,10 @@ RenderSettings *RenderSettings::inst(bool erase)
 
 RenderSettings::RenderSettings()
 {
+	openCSGTermLimit = 2000;
+	far_gl_clip_limit = 100000.0;
+	img_width = 512;
+	img_height = 512;
 	this->colors[BACKGROUND_COLOR] = Color4f(0xff, 0xff, 0xe5);
 	this->colors[OPENCSG_FACE_FRONT_COLOR] = Color4f(0xf9, 0xd7, 0x2c);
 	this->colors[OPENCSG_FACE_BACK_COLOR] = Color4f(0x9d, 0xcb, 0x51);
diff --git a/src/rendersettings.h b/src/rendersettings.h
index 15a0746..e4fa6c8 100644
--- a/src/rendersettings.h
+++ b/src/rendersettings.h
@@ -25,6 +25,8 @@ public:
 	void setColors(const std::map<RenderColor, Color4f> &colors);
 	Color4f color(RenderColor idx);
 
+	unsigned int openCSGTermLimit, img_width, img_height;
+	double far_gl_clip_limit;
 private:
 	RenderSettings();
 	~RenderSettings() {}
diff --git a/src/svg.cc b/src/svg.cc
index 4f07f07..a21e844 100644
--- a/src/svg.cc
+++ b/src/svg.cc
@@ -2,13 +2,13 @@
 #include "cgalutils.h"
 #include "svg.h"
 #include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
 #include <map>
 
 namespace OpenSCAD {
 
 // SVG code
 // currently for debugging, not necessarily pretty or useful for users. (yet)
-int svg_cursor_py = 0;
 int svg_px_width = SVG_PXW;
 int svg_px_height = SVG_PXH;
 
@@ -27,6 +27,26 @@ std::string svg_label(std::string s)
 	return out.str();
 }
 
+std::string svg_styleblock(std::string strokewidth)
+{
+	std::stringstream out;
+	// halfedge: f1/f0 = face mark, b1/b0 = body or hole, m1/m0 = halfedge mark
+	out << "\
+ <style type='text/css'>\n\
+  .halfedge_f0_b1_m0 { stroke: gold; stroke-width: __STROKEW__px } \n\
+  .halfedge_f0_b1_m1 { stroke: gold; stroke-width: __STROKEW__px } \n\
+  .halfedge_f0_b0_m0 { stroke: green; stroke-width: __STROKEW__px } \n\
+  .halfedge_f0_b0_m1 { stroke: green; stroke-width: __STROKEW__px } \n\
+  .halfedge_f1_b1_m0 { stroke: gold; stroke-width: __STROKEW__px } \n\
+  .halfedge_f1_b1_m1 { stroke: gold; stroke-width: __STROKEW__px } \n\
+  .halfedge_f1_b0_m0 { stroke: green; stroke-width: __STROKEW__px } \n\
+  .halfedge_f1_b0_m1 { stroke: green; stroke-width: __STROKEW__px } \n\
+ </style>";
+	std::string tmp = out.str();
+	boost::replace_all( tmp, "__STROKEW__", strokewidth );
+	return tmp;
+}
+
 std::string svg_border()
 {
 	std::stringstream out;
@@ -93,36 +113,27 @@ std::string dump_cgal_nef_polyhedron2_face_svg(
 	CGAL_Nef_polyhedron2::Explorer::Halfedge_around_face_const_circulator c1,
 	CGAL_Nef_polyhedron2::Explorer::Halfedge_around_face_const_circulator c2,
 	CGAL_Nef_polyhedron2::Explorer explorer,
-	std::string color,
-	bool mark,
-	CGAL_Iso_rectangle_2e bbox )
+	bool facemark, bool body )
 {
+	std::stringstream style;
+	style << "halfedge_f" << facemark << "_b" << body << "_m";
+	std::string styleclass = style.str();
+
   std::stringstream out;
 	CGAL_For_all(c1, c2) {
 		if ( explorer.is_standard( explorer.target(c1) ) ) {
 CGAL_Nef_polyhedron2::Explorer::Point source = explorer.point( explorer.source( c1 ) );
 			CGAL_Point_2e target = explorer.point( explorer.target( c1 ) );
-			CGAL_Point_2e tp1 = project_svg_2to2( source, bbox );
-			CGAL_Point_2e tp2 = project_svg_2to2( target, bbox );
-			double mod=0;
-			if (color=="green") mod=10;
-			out << "      <!-- Halfedge. Mark: " << c1->mark() << " -->\n";
-      out << "       <line"
-			  << " x1='" << CGAL::to_double(tp1.x()) + mod << "'"
-			  << " y1='" << CGAL::to_double(tp1.y()) - mod << "'"
-			  << " x2='" << CGAL::to_double(tp2.x()) + mod << "'"
-			  << " y2='" << CGAL::to_double(tp2.y()) - mod << "'"
-			  << " stroke='" << color << "'";
-			if (!mark) out << " stroke-dasharray='4 4' />\n";
-			else out << " />\n";
-			// crude "arrowhead" to indicate directionality
-			out << "       <circle"
-			  << " cx='" << CGAL::to_double(tp1.x()+ (tp2.x()-tp1.x())* 7/8) + mod << "'"
-			  << " cy='" << CGAL::to_double(tp1.y()+ (tp2.y()-tp1.y())* 7/8) - mod << "'"
-			  << " r='2'"
-			  << " fill='" << color << "' stroke='" << color << "' />\n";
+			out << "    <!-- Halfedge. Mark: " << c1->mark() << " -->\n";
+			std::string he_mark = boost::lexical_cast<std::string>(c1->mark());
+      out << "     <line"
+			  << " x1='" << CGAL::to_double(source.x()) << "'"
+			  << " y1='" << CGAL::to_double(source.y()) << "'"
+			  << " x2='" << CGAL::to_double(target.x()) << "'"
+			  << " y2='" << CGAL::to_double(target.y()) << "'"
+			  << " class='" << styleclass + he_mark << "' />\n";
 		} else {
-			out << "       <!-- 2d Nef Rays - not implemented -->\n";
+			out << "     <!-- 2d Nef Rays - not implemented -->\n";
 		}
 	}
 	return out.str();
@@ -132,27 +143,27 @@ std::string dump_svg( const CGAL_Nef_polyhedron2 &N )
 {
   std::stringstream out;
   CGAL_Nef_polyhedron2::Explorer explorer = N.explorer();
-
 	CGAL_Iso_rectangle_2e bbox = bounding_box( N );
-
   CGAL_Nef_polyhedron2::Explorer::Face_const_iterator i;
-  out << " <svg y='" << svg_cursor_py << "' width='" << svg_px_width
-		<< "' height='" << svg_px_height
-		<< "' xmlns='http://www.w3.org/2000/svg' version='1.1'>\n";
-	out << svg_border() << "\n" << svg_axes() << "\n";
-	svg_cursor_py += svg_px_height;
+
+	std::string linewidth = "0.05";
+
+	out << "<!--CGAL_Nef_polyhedron2 dump begin-->\n";
+	out << svg_header() << "\n" << svg_styleblock( linewidth ) << "\n";
 
 	for ( i = explorer.faces_begin(); i!= explorer.faces_end(); ++i ) {
 			out << "  <!-- face begin. mark: " << i->mark() << "  -->\n";
+			out << "   <!-- body begin -->\n";
 			CGAL_Nef_polyhedron2::Explorer::Halfedge_around_face_const_circulator c1
 				= explorer.face_cycle( i ), c2 ( c1 );
-			out << dump_cgal_nef_polyhedron2_face_svg( c1, c2, explorer, "red", i->mark(), bbox );
+			out << dump_cgal_nef_polyhedron2_face_svg( c1, c2, explorer, i->mark(), true );
+			out << "   <!-- body end -->\n";
 
 		  CGAL_Nef_polyhedron2::Explorer::Hole_const_iterator j;
 			for ( j = explorer.holes_begin( i ); j!= explorer.holes_end( i ); ++j ) {
 				out << "   <!-- hole begin. mark: " << j->mark() << " -->\n";
 				CGAL_Nef_polyhedron2::Explorer::Halfedge_around_face_const_circulator c3( j ), c4 ( c3 );
-				out << dump_cgal_nef_polyhedron2_face_svg( c3, c4, explorer, "green", j->mark(), bbox );
+				out << dump_cgal_nef_polyhedron2_face_svg( c3, c4, explorer, "green", j->mark() );
 				out << "   <!-- hole end -->\n";
 			}
 			out << "  <!-- face end -->\n";
@@ -182,13 +193,13 @@ public:
 	void visit( CGAL_Nef_polyhedron3::Halffacet_const_handle hfacet )
 	{
 		int contour_count = 0;
-		out << "  <!-- Halffacet. Mark: " << (*hfacet).mark() << " -->\n";
+		out << "  <!-- Halffacet visit. Mark: " << (*hfacet).mark() << " -->\n";
 		std::string color = "gold";
 		if (!(*hfacet).mark()) color = "green";
 		CGAL_Nef_polyhedron3::Halffacet_cycle_const_iterator i;
 		CGAL_forall_facet_cycles_of( i, hfacet ) {
 			CGAL_Nef_polyhedron3::SHalfloop_const_handle shl_handle;
-			out << "   <!-- Halffacet cycle: -->\n";
+			out << "   <!-- Halffacet cycle begin: -->\n";
 			if ( contour_count == 0 ) {
 				out << "    <!-- Body contour:--> \n";
 			} else {
@@ -196,13 +207,15 @@ public:
 			}
 			CGAL_Nef_polyhedron3::SHalfedge_around_facet_const_circulator c1(i), c2(c1);
 			CGAL_For_all( c1, c2 ) {
-				out << "     <line";
 				// don't know why we use source()->source(), except thats what CGAL does internally
 				CGAL_Point_3 source = c1->source()->source()->point();
 				CGAL_Point_3 target = c1->source()->target()->point();
 				CGAL_Point_2e tp1 = project_svg_3to2 ( source, bbox );
 				CGAL_Point_2e tp2 = project_svg_3to2 ( target, bbox );
-				out << " "
+        out << "     <!-- " << CGAL::to_double(source.x()) << ","
+          << CGAL::to_double(source.y()) << ","
+          << CGAL::to_double(source.z()) << " -->\n";
+				out << "     <line "
 					<< "x1='" << CGAL::to_double(tp1.x()) << "' "
 					<< "y1='" << CGAL::to_double(tp1.y()) << "' "
 					<< "x2='" << CGAL::to_double(tp2.x()) << "' "
@@ -212,31 +225,34 @@ public:
 				else out << " />\n";
 			}
 			contour_count++;
-		} // next facet cycle (i.e. next contour)
-	} // visit()
-
+			out << "   <!-- Halffacet cycle end -->\n";
+		}
+		out << "  <!-- Halffacet visit end -->\n";
+	}
 };
 
 
 std::string dump_svg( const CGAL_Nef_polyhedron3 &N )
 {
   std::stringstream out;
-	out << svg_header() << "\n" << svg_border() << "\n" << svg_axes() << "\n";
+	std::string linewidth = "0.05";
 	out << "<!--CGAL_Nef_polyhedron3 dump begin-->\n";
+	out << svg_header() << "\n" << svg_border() << "\n";
+	out << svg_styleblock( linewidth ) << "\n" << svg_axes() << "\n";
 
   CGAL_Nef_polyhedron3::Volume_const_iterator c;
   CGAL_forall_volumes(c,N) {
-    out << " <!--Processing volume...-->\n";
+    out << " <!--Volume begin-->\n";
     out << "  <!--Mark: " << (*c).mark() << "-->\n";
     CGAL_Nef_polyhedron3::Shell_entry_const_iterator it;
     CGAL_forall_shells_of(it,c) {
-      out << "  <!--Processing shell...-->\n";
+      out << "  <!--Shell begin-->\n";
       NefPoly3_dumper_svg dumper_svg(N);
       N.visit_shell_objects(CGAL_Nef_polyhedron3::SFace_const_handle(it), dumper_svg );
 			out << dumper_svg.out.str();
-      out << "  <!--Processing shell end-->\n";
+      out << "  <!--Shell end-->\n";
     }
-    out << " <!--Processing volume end-->\n";
+    out << " <!--Volume end-->\n";
   }
   out << "<!--CGAL_Nef_polyhedron3 dump end-->\n";
 	out << "</svg>";
diff --git a/src/system-gl.cc b/src/system-gl.cc
new file mode 100644
index 0000000..0c436e5
--- /dev/null
+++ b/src/system-gl.cc
@@ -0,0 +1,89 @@
+
+/* OpenGL helper functions */
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <string>
+#include "system-gl.h"
+#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
+
+using namespace std;
+using namespace boost;
+
+double gl_version()
+{
+	string tmp((const char*)glGetString( GL_VERSION ));
+	vector<string> strs;
+	split(strs, tmp, is_any_of("."));
+	stringstream out;
+	if ( strs.size() >= 2)
+		out << strs[0] << "." << strs[1];
+	else
+		out << "0.0";
+	double d;
+	out >> d;
+	return d;
+}
+
+string glew_extensions_dump()
+{
+	std::string tmp;
+	if ( gl_version() >= 3.0 ) {
+    GLint numexts = 0;
+    glGetIntegerv(GL_NUM_EXTENSIONS, &numexts);
+    for ( int i=0;i<numexts;i++ ) {
+			tmp += (const char *) glGetStringi(GL_EXTENSIONS, i);
+			tmp += " ";
+		}
+	} else {
+ 	 tmp = (const char *) glGetString(GL_EXTENSIONS);
+	}
+	vector<string> extensions;
+	split( extensions, tmp, is_any_of(" "));
+	sort( extensions.begin(), extensions.end() );
+	stringstream out;
+	out << "GL Extensions:";
+	for ( int i=0;i<extensions.size();i++ )	out << extensions[i] << "\n";
+	return out.str();
+}
+
+string glew_dump()
+{
+  GLint rbits, gbits, bbits, abits, dbits, sbits;
+  glGetIntegerv(GL_RED_BITS, &rbits);
+  glGetIntegerv(GL_GREEN_BITS, &gbits);
+  glGetIntegerv(GL_BLUE_BITS, &bbits);
+  glGetIntegerv(GL_ALPHA_BITS, &abits);
+  glGetIntegerv(GL_DEPTH_BITS, &dbits);
+  glGetIntegerv(GL_STENCIL_BITS, &sbits);
+
+  stringstream out;
+  out << "GLEW version: " << glewGetString(GLEW_VERSION)
+      << "\nOpenGL Version: " << (const char *)glGetString(GL_VERSION)
+      << "\nGL Renderer: " << (const char *)glGetString(GL_RENDERER)
+      << "\nGL Vendor: " << (const char *)glGetString(GL_VENDOR)
+      << boost::format("\nRGBA(%d%d%d%d), depth(%d), stencil(%d)") %
+          rbits % gbits % bbits % abits % dbits % sbits;
+  out << "\nGL_ARB_framebuffer_object: "
+      << (glewIsSupported("GL_ARB_framebuffer_object") ? "yes" : "no")
+      << "\nGL_EXT_framebuffer_object: "
+      << (glewIsSupported("GL_EXT_framebuffer_object") ? "yes" : "no")
+      << "\nGL_EXT_packed_depth_stencil: "
+      << (glewIsSupported("GL_EXT_packed_depth_stencil") ? "yes" : "no")
+	    << "\n";
+  return out.str();
+};
+
+bool report_glerror(const char * function)
+{
+  GLenum tGLErr = glGetError();
+  if (tGLErr != GL_NO_ERROR) {
+    cerr << "OpenGL error 0x" << hex << tGLErr << ": " << gluErrorString(tGLErr) << " after " << function << endl;
+    return true;
+  }
+  return false;
+}
+
diff --git a/src/system-gl.h b/src/system-gl.h
index d7de3c6..4a9474f 100644
--- a/src/system-gl.h
+++ b/src/system-gl.h
@@ -13,4 +13,10 @@
  #endif
 #endif
 
+#include <string>
+
+std::string glew_dump();
+std::string glew_extensions_dump();
+bool report_glerror(const char * function);
+
 #endif
diff --git a/src/transform.cc b/src/transform.cc
index 0f678c5..b01827f 100644
--- a/src/transform.cc
+++ b/src/transform.cc
@@ -29,6 +29,8 @@
 #include "context.h"
 #include "polyset.h"
 #include "builtin.h"
+#include "value.h"
+#include "printutils.h"
 #include <sstream>
 #include <vector>
 #include <assert.h>
@@ -188,8 +190,8 @@ std::string TransformNode::toString() const
 	for (int j=0;j<4;j++) {
 		stream << "[";
 		for (int i=0;i<4;i++) {
-			// FIXME: The 0 test is to avoid a leading minus before a single 0 (cosmetics)
-			stream << ((this->matrix(j, i)==0)?0:this->matrix(j, i));
+			Value v( this->matrix(j, i) );
+			stream << v;
 			if (i != 3) stream << ", ";
 		}
 		stream << "]";
diff --git a/src/value.cc b/src/value.cc
index 7744a18..f14f826 100644
--- a/src/value.cc
+++ b/src/value.cc
@@ -25,6 +25,7 @@
  */
 
 #include "value.h"
+#include "printutils.h"
 #include <stdio.h>
 #include <math.h>
 #include <assert.h>
@@ -38,7 +39,7 @@
 
 std::ostream &operator<<(std::ostream &stream, const Filename &filename)
 {
-  stream << QuotedString(QDir::current().relativeFilePath(QString::fromStdString(filename)).toStdString());
+  stream << QuotedString(QDir::current().relativeFilePath(QString::fromLocal8Bit(filename.c_str())).toLocal8Bit().constData());
   return stream;
 }
 
@@ -196,15 +197,18 @@ public:
     size_t dotpos = tmpstr.find('.');
     if (dotpos != std::string::npos) {
       if (tmpstr.size() - dotpos > 12) tmpstr.erase(dotpos + 12);
+      while (tmpstr[tmpstr.size()-1] == '0') tmpstr.erase(tmpstr.size()-1);
     }
+    if ( tmpstr.compare("-0") == 0 ) tmpstr = "0";
+    tmpstr = two_digit_exp_format( tmpstr );
     return tmpstr;
 #else
-		// attempt to emulate Qt's QString.sprintf("%g"); from old OpenSCAD.
-		// see https://github.com/openscad/openscad/issues/158
-		std::stringstream tmp;
-		tmp.unsetf(std::ios::floatfield);
-		tmp << op1;
-		return tmp.str();
+    // attempt to emulate Qt's QString.sprintf("%g"); from old OpenSCAD.
+    // see https://github.com/openscad/openscad/issues/158
+    std::stringstream tmp;
+    tmp.unsetf(std::ios::floatfield);
+    tmp << op1;
+    return tmp.str();
 #endif
   }
 
diff --git a/src/value.h b/src/value.h
index 24fbf49..0445ff4 100644
--- a/src/value.h
+++ b/src/value.h
@@ -3,8 +3,12 @@
 
 #include <vector>
 #include <string>
+
+// Workaround for https://bugreports.qt-project.org/browse/QTBUG-22829
+#ifndef Q_MOC_RUN
 #include <boost/variant.hpp>
 #include <boost/lexical_cast.hpp>
+#endif
 
 class QuotedString : public std::string
 {