swfmill 0.0.1

data/ext/swfmill/src/swft/swft.cpp

@@ -0,0 +1,251 @@
+#include <libxslt/extensions.h>
+#include <libxml/uri.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/variables.h>
+#include <libxml/xpathInternals.h>
+#include <cstdlib>
+#include <cstring>
+#include "swft.h"
+
+#define TMP_STRLEN 0xFF
+#define SWFT_MAPSIZE 32
+
+using namespace SWF;
+
+void *swft_init( xsltTransformContextPtr ctx, const xmlChar *URI );
+void swft_shutdown( xsltTransformContextPtr ctx, const xmlChar *URI, void *data );
+
+static void swft_error( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp );
+
+static void swft_nextid( xmlXPathParserContextPtr ctx, int nargs );
+static void swft_nextdepth( xmlXPathParserContextPtr ctx, int nargs );
+
+static void swft_pushmap( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp );
+static void swft_popmap( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp );
+
+static void swft_mapid( xmlXPathParserContextPtr ctx, int nargs );
+static void swft_setmap( xmlXPathParserContextPtr ctx, int nargs );
+
+// in swft_import_*.cpp
+// FIXME why are these not static? any reason?
+void swft_import_jpeg( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_jpega( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_png( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_ttf( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_mp3( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_wav( xmlXPathParserContextPtr ctx, int nargs );
+void swft_import_binary( xmlXPathParserContextPtr ctx, int nargs );
+
+// in swft_document
+void swft_document( xmlXPathParserContextPtr ctx, int nargs );
+
+// in swft_path
+void swft_path( xmlXPathParserContextPtr ctx, int nargs );
+void swft_bounds( xmlXPathParserContextPtr ctx, int nargs );
+void swft_transform( xmlXPathParserContextPtr ctx, int nargs );
+
+static void swft_pushgradient( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr com ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( ctx, SWFT_NAMESPACE );
+	xmlChar *id, *href;
+	SVGGradient *gradient;
+
+	id = xmlGetProp(node, (const xmlChar *)"id");
+	if(id) {
+		if(!xmlStrcmp(node->name, (const xmlChar *)"linearGradient")) {
+			gradient = new SVGLinearGradient();
+		} else if(!xmlStrcmp(node->name, (const xmlChar *)"radialGradient")) {
+			gradient = new SVGRadialGradient();
+		}
+
+		href = xmlGetProp(node, (const xmlChar *)"href");
+		if (href) {
+			string hrefStr = (const char *)href;
+			hrefStr.erase(0, 1);
+
+			map<string, SVGGradient*>::iterator i = c->gradients.find(hrefStr);
+			if(i != c->gradients.end()) {
+				*gradient = *((*i).second);
+			}			
+
+			xmlFree(href);
+		}
+
+		gradient->parse(node);
+		c->gradients[(char *)id] = gradient;
+		xmlFree(id);
+	}
+
+}
+
+static void swft_popstyle( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr com ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( ctx, SWFT_NAMESPACE );
+	c->styles.pop();
+}
+
+static void swft_pushstyle( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr com ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( ctx, SWFT_NAMESPACE );
+
+	SVGStyle style;
+	if(c->styles.size() > 0) {
+		style = c->styles.top();
+	}
+	style.parseNode(node, c->gradients);
+	c->styles.push(style);
+}
+
+static void swft_nextid( xmlXPathParserContextPtr ctx, int nargs ) {
+	char tmp[TMP_STRLEN];
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+	snprintf(tmp,TMP_STRLEN,"%i", c->last_id++ );
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)tmp));
+}
+
+static void swft_nextdepth( xmlXPathParserContextPtr ctx, int nargs ) {
+	char tmp[TMP_STRLEN];
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+	snprintf(tmp,TMP_STRLEN,"%i", c->last_depth++ );
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)tmp));
+}
+
+static void swft_pushmap( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( ctx, SWFT_NAMESPACE );
+	c->pushMap();
+}
+
+static void swft_popmap( xsltTransformContextPtr ctx, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( ctx, SWFT_NAMESPACE );
+	c->popMap();
+}
+
+static void swft_setmap( xmlXPathParserContextPtr ctx, int nargs ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+
+	if( (nargs != 2) ) {
+		xmlXPathSetArityError(ctx);
+		return;
+	}
+	
+	int to = (int)xmlXPathPopNumber(ctx);
+	xmlChar *from = xmlXPathPopString(ctx);
+	if( xmlXPathCheckError(ctx) )
+		return;
+	
+	c->setMap((const char *)from,to);
+	
+	xmlFree( from );
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)""));
+}
+
+static void swft_bump_id( xmlXPathParserContextPtr ctx, int nargs ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+
+	if( (nargs != 1) ) {
+		xmlXPathSetArityError(ctx);
+		return;
+	}
+	
+	int offset = (int)xmlXPathPopNumber(ctx);
+	if( xmlXPathCheckError(ctx) )
+		return;
+	
+	if( offset >= c->last_id ) c->last_id = offset+1;
+	
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)""));
+}
+
+static void swft_bump_depth( xmlXPathParserContextPtr ctx, int nargs ) {
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+
+	if( (nargs != 1) ) {
+		xmlXPathSetArityError(ctx);
+		return;
+	}
+	
+	int offset = (int)xmlXPathPopNumber(ctx);
+	if( xmlXPathCheckError(ctx) )
+		return;
+	
+	if( offset >= c->last_depth ) c->last_depth = offset+1;
+	
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)""));
+}
+
+static void swft_mapid( xmlXPathParserContextPtr ctx, int nargs ) {
+	char tmp[TMP_STRLEN];
+	xmlXPathObjectPtr obj;
+	xmlChar *oldID;
+	int newID;
+	swft_ctx *c = (swft_ctx*)xsltGetExtData( xsltXPathGetTransformContext(ctx), SWFT_NAMESPACE );
+
+	xmlXPathStringFunction(ctx, 1);
+	if (ctx->value->type != XPATH_STRING) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+			 "swft:mapid() : invalid arg expecting a string (the old id)\n");
+		ctx->error = XPATH_INVALID_TYPE;
+		return;
+	}
+	obj = valuePop(ctx);
+	if (obj->stringval == NULL) {
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+	// (int)xmlXPathStringEvalNumber()
+	oldID = obj->stringval;
+	newID = c->doMap((const char*)oldID);
+
+	xmlFree( oldID );
+	
+	snprintf(tmp,TMP_STRLEN,"%i", newID );
+	valuePush(ctx, xmlXPathNewString((const xmlChar *)tmp));
+}
+
+unsigned char *swft_get_filename( xmlChar *filenameUTF ) {
+	int l = strlen((const char*)filenameUTF);
+	int l2 = l;
+	unsigned char *filename = (unsigned char *)malloc(l+1);
+	UTF8Toisolat1( filename, &l2, filenameUTF, &l );
+	filename[l2] = 0;
+	return filename;
+}
+
+void swft_register() {
+	xsltRegisterExtModule((const xmlChar *)SWFT_NAMESPACE,
+		swft_init, swft_shutdown );
+}
+
+void *swft_init( xsltTransformContextPtr ctx, const xmlChar *URI ) {
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "next-id", SWFT_NAMESPACE, swft_nextid);
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "next-depth", SWFT_NAMESPACE, swft_nextdepth);
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "map-id", SWFT_NAMESPACE, swft_mapid);
+	xsltRegisterExtElement(  ctx, (const xmlChar *) "push-map", SWFT_NAMESPACE, swft_pushmap);
+	xsltRegisterExtElement(  ctx, (const xmlChar *) "pop-map", SWFT_NAMESPACE, swft_popmap);
+	xsltRegisterExtFunction(  ctx, (const xmlChar *) "set-map", SWFT_NAMESPACE, swft_setmap);
+	xsltRegisterExtFunction(  ctx, (const xmlChar *) "bump-id", SWFT_NAMESPACE, swft_bump_id);
+	xsltRegisterExtFunction(  ctx, (const xmlChar *) "bump-depth", SWFT_NAMESPACE, swft_bump_depth);
+
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "document", SWFT_NAMESPACE, swft_document);
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "path", SWFT_NAMESPACE, swft_path);
+//	xsltRegisterExtFunction( ctx, (const xmlChar *) "bounds", SWFT_NAMESPACE, swft_bounds);
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "transform", SWFT_NAMESPACE, swft_transform);
+	xsltRegisterExtElement( ctx, (const xmlChar *) "push-style", SWFT_NAMESPACE, swft_pushstyle);
+	xsltRegisterExtElement( ctx, (const xmlChar *) "pop-style", SWFT_NAMESPACE, swft_popstyle);
+	xsltRegisterExtElement( ctx, (const xmlChar *) "push-gradient", SWFT_NAMESPACE, swft_pushgradient);
+
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-jpeg", SWFT_NAMESPACE, swft_import_jpeg );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-jpega", SWFT_NAMESPACE, swft_import_jpega );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-png", SWFT_NAMESPACE, swft_import_png );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-ttf", SWFT_NAMESPACE, swft_import_ttf );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-mp3", SWFT_NAMESPACE, swft_import_mp3 );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-wav", SWFT_NAMESPACE, swft_import_wav );
+	xsltRegisterExtFunction( ctx, (const xmlChar *) "import-binary", SWFT_NAMESPACE, swft_import_binary );
+	
+	swft_ctx *c = new swft_ctx;
+	return c;
+}
+
+void swft_shutdown( xsltTransformContextPtr ctx, const xmlChar *URI, void *data ) {
+	swft_ctx *c = (swft_ctx*)data;
+	delete c;
+}
+
+

data/ext/swfmill/src/swft/swft.h

@@ -0,0 +1,64 @@
+#ifndef SWF_SWFT_H
+#define SWF_SWFT_H
+
+#include <libxml/xpathInternals.h>
+#include <string>
+#include <stack>
+#include <map>
+#include "SVGGradient.h"
+#include "SVGStyle.h"
+
+void swft_register();
+	
+// utility functoins for import (in swft_import.cpp)
+void swft_addFileName( xmlNodePtr node, const char *filename );
+void swft_addData( xmlNodePtr node, char *data, int length );
+
+unsigned char *swft_get_filename( xmlChar *string );
+
+#define SWFT_NAMESPACE ((const xmlChar*)"http://subsignal.org/swfml/swft")
+
+class swft_ctx {
+public:
+	std::stack<SWF::SVGStyle> styles;
+	std::map<std::string, SWF::SVGGradient*> gradients;
+
+	int last_id;
+	int last_depth;
+	std::stack<std::map<std::string,int>*> maps;
+
+	bool quiet;
+
+	swft_ctx() {
+		last_id = last_depth = 1;
+		pushMap();
+	}
+
+	void pushMap() {
+		maps.push( new std::map<std::string,int> );
+	}
+	void popMap() {
+		maps.pop();
+	}
+	
+	int doMap( const char *oldID ) {
+        int id = atoi( oldID );
+        if( id == 65535 ) return id;
+            
+		std::map<std::string,int>& m = *(maps.top());
+		int r = m[oldID];
+		if( r == 0 ) {
+			r = last_id++;
+			m[oldID] = r;
+		}
+		
+		return r;
+	}
+	
+	void setMap( const char *oldID, int newID ) {
+		std::map<std::string,int>& m = *(maps.top());
+		m[oldID] = newID;
+	}
+};
+
+#endif

data/ext/swfmill/src/swft/swft_document.cpp

@@ -0,0 +1,57 @@
+#include "SWFShapeMaker.h"
+#include "SWFFile.h"
+#include "swft.h"
+#include <libxslt/extensions.h>
+#include <libxml/uri.h>
+#include <libxslt/xsltutils.h>
+#include <libxml/xpathInternals.h>
+
+using namespace SWF;
+
+void swft_document( xmlXPathParserContextPtr ctx, int nargs ) {
+	xsltTransformContextPtr tctx;
+	xmlChar *uri;
+	xsltDocumentPtr xsltdoc;
+	xmlDocPtr doc = NULL;
+	xmlXPathObjectPtr obj;
+	xmlChar *base = NULL;
+	char sig;
+	File import;
+
+	xmlXPathStringFunction(ctx, 1);
+	if (ctx->value->type != XPATH_STRING) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+			 "swft:document() : invalid arg expecting a string\n");
+		ctx->error = XPATH_INVALID_TYPE;
+		return;
+	}
+	obj = valuePop(ctx);
+	if (obj->stringval == NULL) {
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+		
+	tctx = xsltXPathGetTransformContext(ctx);
+	
+	uri = swft_get_filename( obj->stringval );
+		
+	FILE *fp = fopen( (const char *)uri, "rb" );
+	if( !fp ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:document() : failed to read file '%s'\n", (const char *)uri);
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+	
+	import.load( fp );
+	doc = import.getXML();
+	
+	if( !doc ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:document() : could not parse SWF '%s'\n", (const char *)uri);
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+	valuePush( ctx, xmlXPathNewNodeSet( (xmlNodePtr)doc ) );
+	return;
+}

data/ext/swfmill/src/swft/swft_import.cpp

@@ -0,0 +1,38 @@
+#include <libxslt/extensions.h>
+#include <libxslt/xsltutils.h>
+#include <libxml/xpathInternals.h>
+#include "base64.h"
+#include <cstring>
+
+void swft_addFileName( xmlNodePtr node, const char *filename ) {
+	char *name, *n;
+	const char *basename, *b;
+	int l;
+	
+	// figure basename (filename without path)
+	b = strrchr( filename, '/' );
+	basename = b ? b+1 : filename;
+	
+	l = strlen(basename);
+	name = new char[l + 1];
+	strncpy( name, basename, l + 1 ); // copy string including null terminator
+	
+	// separate extension (set position of last . as end of string)
+	n = strrchr( name, '.' );
+	if( n ) n[0]=0;
+	
+	xmlSetProp( node, (const xmlChar *)"name", (const xmlChar *)name );
+	
+	delete[] name;
+}
+
+void swft_addData( xmlNodePtr node, char *data, int sz ) {
+	char *tmpstr = new char[ (sz * 3) ];
+	
+	int l = base64_encode( tmpstr, data, sz );
+	if( l > 0 ) {
+		tmpstr[l] = 0;
+		xmlNewTextChild( node, NULL, (const xmlChar *)"data", (const xmlChar *)tmpstr );
+	}
+	delete tmpstr;
+}

data/ext/swfmill/src/swft/swft_import_binary.cpp

@@ -0,0 +1,82 @@
+#include <libxslt/extensions.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/variables.h>
+#include <libxml/xpathInternals.h>
+#include "swft.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <cstring>
+#include "readpng.h"
+#include <zlib.h>
+
+#define TMP_STRLEN 0xff
+
+void swft_import_binary( xmlXPathParserContextPtr ctx, int nargs ) {
+	xsltTransformContextPtr tctx;
+	unsigned char *filename;
+	xsltDocumentPtr xsltdoc;
+	xmlDocPtr doc = NULL;
+	xmlNodePtr node;
+	xmlXPathObjectPtr obj;
+	char tmp[TMP_STRLEN];
+
+	xmlXPathStringFunction(ctx, 1);
+	if (ctx->value->type != XPATH_STRING) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+			 "swft:import-binary() : invalid arg expecting a string\n");
+		ctx->error = XPATH_INVALID_TYPE;
+		return;
+	}
+	obj = valuePop(ctx);
+	if (obj->stringval == NULL) {
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+		
+	tctx = xsltXPathGetTransformContext(ctx);
+	filename = swft_get_filename( obj->stringval );
+
+	bool quiet = true;
+	xmlXPathObjectPtr quietObj = xsltVariableLookup( tctx, (const xmlChar*)"quiet", NULL );
+	if( quietObj && quietObj->stringval ) { quiet = !strcmp("true",(const char*)quietObj->stringval ); };
+
+	
+	FILE *fp = fopen( (const char *)filename, "rb" );
+	if( !fp ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-binary() : failed to read file '%s'\n", (const char *)filename);
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		return;
+	}
+	
+	doc = xmlNewDoc( (const xmlChar *)"1.0");
+	doc->xmlRootNode = xmlNewDocNode( doc, NULL, (const xmlChar *)"binary", NULL );
+	node = doc->xmlRootNode;
+	
+	swft_addFileName( node, (const char *)filename );
+	
+	// add data
+	unsigned char *data = NULL;
+	int size;
+	struct stat filestat;
+	if( stat( (const char *)filename, &filestat ) ) goto fail;
+	size = filestat.st_size;
+	
+	data = new unsigned char[size];
+	if( fread( data, 1, size, fp ) != size ) {
+		fprintf(stderr,"WARNING: could not read enough (%i) bytes for binary %s\n", size, filename );
+		goto fail;
+	}
+
+	if( !quiet ) {
+		fprintf(stderr,"Importing binary: '%s'\n",filename);
+	}
+	
+	swft_addData( node, (char*)data, size );
+	valuePush( ctx, xmlXPathNewNodeSet( (xmlNodePtr)doc ) );
+
+fail:	
+	if( fp ) fclose(fp);
+	if( data ) delete data;
+}
+