swfmill 0.0.1

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

@@ -0,0 +1,255 @@
+#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
+const char jpeg_header[] = { 0xff, 0xd9, 0xff, 0xd8, 0 };
+
+// defined in swft_import_png
+bool compress( unsigned char *inputBuffer, int inLength, unsigned char *outputBuffer, int *outLength );
+
+
+int getJpegWord( FILE *fp ) {
+	int r = fgetc(fp);
+	r <<= 8;
+	r += fgetc(fp);
+	return r;
+}
+
+void swft_import_jpeg( 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-jpeg() : 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-jpeg() : 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 *)"jpeg", NULL );
+	node = doc->xmlRootNode;
+	
+	swft_addFileName( node, (const char *)filename );
+	
+	// figure width/height
+	int width=-1, height=-1;
+	while( !feof( fp ) ) { // could do a && width==-1 here, but that captures preview imgs...
+		if( fgetc(fp) == 0xff ) {
+			if( fgetc(fp) == 0xc0 ) {
+				// StartOfFrame
+				// skip length and precision (UGLY, eh?)
+				fgetc(fp); fgetc(fp); fgetc(fp);
+				
+				// read height, width
+				height = getJpegWord( fp );
+				width = getJpegWord( fp );
+			}
+		}
+	}
+	snprintf(tmp,TMP_STRLEN,"%i", width);
+	xmlSetProp( node, (const xmlChar *)"width", (const xmlChar *)&tmp );
+	snprintf(tmp,TMP_STRLEN,"%i", height);
+	xmlSetProp( node, (const xmlChar *)"height", (const xmlChar *)&tmp );
+	
+	// add data
+	unsigned char *data = NULL;
+	int size, ofs;
+	struct stat filestat;
+	if( stat( (const char *)filename, &filestat ) ) goto fail;
+	size = filestat.st_size;
+	
+	ofs = strlen(jpeg_header);
+	
+	rewind(fp);
+	data = new unsigned char[size+ofs];
+	memcpy( data, jpeg_header, ofs );
+	if( fread( &data[ofs], 1, size, fp ) != size ) {
+		fprintf(stderr,"WARNING: could not read enough (%i) bytes for jpeg %s\n", size, filename );
+		goto fail;
+	}
+
+	if( !quiet ) {
+		fprintf(stderr,"Importing JPG: '%s'\n",filename);
+	}
+	
+	swft_addData( node, (char*)data, size+ofs );
+	valuePush( ctx, xmlXPathNewNodeSet( (xmlNodePtr)doc ) );
+
+fail:	
+	if( fp ) fclose(fp);
+	if( data ) delete data;
+}
+
+
+void swft_import_jpega( xmlXPathParserContextPtr ctx, int nargs ) {
+	xsltTransformContextPtr tctx;
+	xmlChar *filename, *maskfilename;
+	xsltDocumentPtr xsltdoc;
+	xmlDocPtr doc = NULL;
+	xmlNodePtr node;
+	xmlXPathObjectPtr obj;
+	char tmp[TMP_STRLEN];
+
+	if( (nargs != 2) ) {
+		xmlXPathSetArityError(ctx);
+		return;
+	}
+
+	maskfilename = swft_get_filename( xmlXPathPopString(ctx) );
+	filename = swft_get_filename( xmlXPathPopString(ctx) );
+	if( xmlXPathCheckError(ctx) || (filename==NULL) || (maskfilename==NULL) ) {
+		return;
+	}
+		
+	tctx = xsltXPathGetTransformContext(ctx);
+		
+	FILE *fp = fopen( (const char *)filename, "rb" );
+	if( !fp ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-jpega() : 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 *)"jpega", NULL );
+	node = doc->xmlRootNode;
+	
+	swft_addFileName( node, (const char *)filename );
+	
+	// figure width/height
+	int width=-1, height=-1;
+	while( !feof( fp ) ) { // could do a && width==-1 here, but that captures preview imgs...
+		if( fgetc(fp) == 0xff ) {
+			if( fgetc(fp) == 0xc0 ) {
+				// StartOfFrame
+				// skip length and precision (UGLY, eh?)
+				fgetc(fp); fgetc(fp); fgetc(fp);
+				
+				// read height, width
+				height = getJpegWord( fp );
+				width = getJpegWord( fp );
+			}
+		}
+	}
+	snprintf(tmp,TMP_STRLEN,"%i", width);
+	xmlSetProp( node, (const xmlChar *)"width", (const xmlChar *)&tmp );
+	snprintf(tmp,TMP_STRLEN,"%i", height);
+	xmlSetProp( node, (const xmlChar *)"height", (const xmlChar *)&tmp );
+	
+	// add data
+	unsigned char *jpegdata = NULL;
+	unsigned char *data = NULL;
+	int data_size, mask_size;
+	int size, ofs;
+	struct stat filestat;
+	unsigned char *maskdata;
+	unsigned long maskw, maskh, rowbytes;
+	int channels;
+	png_colorp palette;
+	int n_pal;
+	unsigned char *mask;
+	if( stat( (const char *)filename, &filestat ) ) goto fail;
+	size = filestat.st_size;
+	
+	ofs = strlen(jpeg_header);
+	
+	rewind(fp);
+	jpegdata = new unsigned char[size+ofs];
+	memcpy( jpegdata, jpeg_header, ofs );
+	if( fread( &jpegdata[ofs], 1, size, fp ) != size ) {
+		fprintf(stderr,"WARNING: could not read enough (%i) bytes for jpeg %s\n", size, filename );
+		goto fail;
+	}
+
+	snprintf(tmp,TMP_STRLEN,"%i", size+ofs);
+	xmlSetProp( node, (const xmlChar *)"offset_to_alpha", (const xmlChar *)&tmp );
+	
+	fclose(fp);
+		
+	// jpegdata is filled, now read the mask png.
+	fp = fopen( (const char *)maskfilename, "rb" );
+	if( !fp ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-jpega() : failed to read mask file '%s'\n", (const char *)maskfilename);
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		goto fail;
+	}
+
+	data_size = size + ofs + (width*height);
+	data = new unsigned char[ data_size ];
+	memcpy( data, jpegdata, size+ofs );
+	maskdata = &data[ size+ofs ];
+	
+	if( readpng_init( fp, &maskw, &maskh ) ) goto fail;
+	
+	if( maskw != width || maskh != height ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-jpega() : mask has different size than jpeg image: %i/%i and %i/%i\n", width, height, maskw, maskh );
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		goto fail;
+	}
+
+	mask = readpng_get_image( 2.2, &channels, &rowbytes, &palette, &n_pal );
+	if( channels != 1 || rowbytes != width ) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-jpega() : mask is not 8bit grayscale\n");
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		goto fail;
+	}
+	
+	mask_size = data_size;
+	if( compress( mask, width*height, maskdata, &mask_size ) ) {
+		data_size = size + ofs + mask_size;
+	} else {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+				   "swft:import-jpega() : could not compress mask\n" );
+		valuePush(ctx, xmlXPathNewNodeSet(NULL));
+		goto fail;
+	}
+	
+	swft_addData( node, (char*)data, data_size );
+	valuePush( ctx, xmlXPathNewNodeSet( (xmlNodePtr)doc ) );
+
+fail:	
+	if( fp ) fclose(fp);
+	if( data ) delete data;
+	if( jpegdata ) delete jpegdata;
+}
+

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

@@ -0,0 +1,268 @@
+#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>
+
+#define TMP_STRLEN 0xff
+
+#define ERROR_NO_MP3              -1
+#define ERROR_WRONG_SAMPLING_RATE -2
+
+enum {
+	MPEG_V25 = 0,
+	MPEG_RESERVED,
+	MPEG_V2,
+	MPEG_V1,
+};
+
+const int mpegVersionBitrate[] = {
+	1, // V2.5, bitrates same as V2
+	-1, 
+	1, // V2
+	0  // V1
+}; 
+
+// Only Layer3 is supported
+const int mp3Bitrates[][15] = {
+	{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320}, // V1
+	{0,  8, 16, 24, 32, 40, 48, 56,  64,  80,  96, 112, 128, 144, 160},   // V2 & V2.5
+};
+
+
+/* As required in DefineSound, as a function of mpegVersion */
+const int flashSamplingRates[] = {
+	1,  // V25 -> 11025,   
+	-1, // dummy
+	2,  // V2 -> 22050,   
+	3,  // V1 -> 44100;
+};
+
+
+const int samplingRates[][4] = {
+	{11025,  12000,    8000,  -1}, // V2.5
+	{   -1,     -1,      -1,  -1}, // dummy
+	{22050,  24000,   12000,  -1}, // V2
+	{44100,  48000,   32000,  -1}, // V1
+};
+
+struct MP3Info {
+	int samplingRate;
+	int samplesPerFrame;
+	int flashSamplingRateFlag;
+	int frames;
+	int stereo;
+	bool validMP3;
+	bool wrongSamplingRate;
+};
+
+int findFrame( const unsigned char* data, int size, int start ) {
+	int pos = start;
+
+	while( pos < size ) {
+		if( data[pos] == 0xFF && (data[pos + 1] & 0xE0) == 0xE0 ) {
+			return pos;
+		}
+		pos++;
+	}
+
+	return -1;
+}
+
+int getFrameSize( const unsigned char* data, int size, int pos, MP3Info &info) {
+	if( pos + 2 >= size ) {
+		return ERROR_NO_MP3;
+	}
+
+	unsigned char c = data[pos + 1];
+	int mpegVersion = (c & 0x18) >> 3;  // 0:V2.5   1:reserved  2:V2  3:V1
+	int layer = (c & 0x06) >> 1;  // 1 means Layer III
+	
+	// An MP3 file is Layer III, MPEG version any
+	if( layer != 1) {
+		fprintf(stderr, "Error: Layer should be III.\n");
+		return ERROR_NO_MP3;
+	}
+
+	if (mpegVersion == MPEG_RESERVED) {
+		fprintf(stderr, "Error: Unknown MPEG version (reserved).\n");
+		return ERROR_NO_MP3;
+	}
+
+	c = data[pos + 2];
+	int bitrate = (c & 0xF0) >> 4;
+	int samplingRate = (c & 0x0C) >> 2;
+	int padding = (c & 0x02) >> 1;
+	
+	if (bitrate > 14) {
+		fprintf(stderr, "MP3 bitrate field invalid. Corrupt MP3 file?");
+		return ERROR_NO_MP3;
+	}
+
+	info.samplingRate = samplingRates[mpegVersion][samplingRate];
+	info.flashSamplingRateFlag = flashSamplingRates[mpegVersion];
+
+	if( samplingRate != 0 ) {
+		fprintf(stderr, "Sampling rate: %d\n", info.samplingRate);
+		fprintf(stderr, "Error: Flash only supports sampling rates of 44100, 22050 and 11025 Hz\n");
+		return ERROR_WRONG_SAMPLING_RATE;
+	}
+   
+	info.samplesPerFrame = mpegVersion == MPEG_V1 ? 1152 : 576; // Since we deal with Layer III only
+
+	//Calculate the frame size in bytes
+	int br_table = mpegVersionBitrate[mpegVersion];
+	int frameSize = (info.samplesPerFrame / 8) * (mp3Bitrates[br_table][bitrate] * 1000) / info.samplingRate + padding;
+
+	return frameSize;
+}
+
+void getMP3Info( MP3Info& info, const unsigned char* data, int size ) {
+	info.frames = 0;
+	info.stereo = 0;
+	info.validMP3 = true;
+	info.wrongSamplingRate = false;
+	int pos = 0;
+	bool first = true;
+	
+	while( (pos = findFrame( data, size, pos)) >= 0 ) {
+		int frameSize =	getFrameSize( data, size, pos, info );
+		if( frameSize > 0 ) {
+			if( first ) {
+				if(pos + 3 < size) {
+					if((data[pos + 3] & 0xC0) != 0xC0)
+						info.stereo = 1;
+				}
+				first = false;
+			}
+
+			pos += frameSize;
+			info.frames++;
+		} else {
+			if ( frameSize == ERROR_WRONG_SAMPLING_RATE ) {
+				info.wrongSamplingRate = true;
+			} else {
+				info.validMP3 = false;
+			}
+			return;
+		}
+	}
+
+	//no frames found -> no valid mp3
+	if( info.frames == 0 ) {
+		info.validMP3 = false;
+	}
+}
+
+
+void swft_import_mp3( xmlXPathParserContextPtr ctx, int nargs ) {
+	xsltTransformContextPtr tctx;
+	xmlChar *filename;
+	xsltDocumentPtr xsltdoc;
+	xmlDocPtr doc = NULL;
+	xmlNodePtr node;
+	xmlXPathObjectPtr obj;
+	char tmp[TMP_STRLEN];
+	//data variables
+	unsigned char *data = NULL;
+	int size;
+	struct stat filestat;
+
+	xmlXPathStringFunction(ctx, 1);
+	if (ctx->value->type != XPATH_STRING) {
+		xsltTransformError(xsltXPathGetTransformContext(ctx), NULL, NULL,
+			 "swft:import-mp3() : 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 = 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-mp3() : 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 *)"mp3", NULL );
+	node = doc->xmlRootNode;
+	
+	swft_addFileName( node, (const char *)filename );
+	
+	// get file size
+	if( stat( (const char *)filename, &filestat ) ) goto fail;
+	size = filestat.st_size;
+	
+	// flash requires an initial latency value in front of the mp3 data
+	// TODO: check the meaning of this value and set it correctly
+	data = new unsigned char[size + 2];
+	data[0] = 0;
+	data[1] = 0;
+
+	// read data
+	if( fread( &data[2], 1, size, fp ) != size ) {
+		fprintf(stderr,"WARNING: could not read enough (%i) bytes for MP3 %s\n", size, filename );
+		goto fail;
+	}
+	
+	if( size == 0 ) {
+		fprintf(stderr,"WARNING: MP3 %s is empty\n", filename );
+		goto fail;
+	}
+
+	MP3Info info;
+	getMP3Info( info, &data[2], size );
+
+	if( !info.validMP3 ) {
+		fprintf(stderr,"WARNING: this file is not a valid MP3 %s\n", filename );
+		goto fail;
+	}
+
+	if( info.wrongSamplingRate ) {
+		fprintf(stderr,"WARNING: MP3 file %s has a wrong sampling rate\n", filename );
+		goto fail;
+	}
+
+	xmlSetProp( node, (const xmlChar *)"format", (const xmlChar *)"2" ); //MP3
+	
+	snprintf(tmp,TMP_STRLEN,"%i", info.flashSamplingRateFlag);
+	xmlSetProp( node, (const xmlChar *)"rate", (const xmlChar *)&tmp );
+	
+	xmlSetProp( node, (const xmlChar *)"is16bit", (const xmlChar *)"1" ); //MP3 is always 16bit
+	
+	snprintf(tmp,TMP_STRLEN,"%i", info.stereo);
+	xmlSetProp( node, (const xmlChar *)"stereo", (const xmlChar *)&tmp );
+	
+	snprintf(tmp,TMP_STRLEN,"%i", info.frames * info.samplesPerFrame); 
+	xmlSetProp( node, (const xmlChar *)"samples", (const xmlChar *)&tmp );
+	
+	if( !quiet ) {
+		fprintf(stderr, "Importing MP3: '%s'\n", filename); 
+	}
+	
+	swft_addData( node, (char*)data, size + 2 );
+	valuePush( ctx, xmlXPathNewNodeSet( (xmlNodePtr)doc ) );
+
+fail:
+	if( fp ) fclose(fp);
+	if( data ) delete data;
+}
+