swfmill 0.0.1 → 0.0.2

data/ext/swfmill/src/xslt/simple-elements.xslt

@@ -39,6 +39,7 @@
 	<xsl:variable name="frames">
 		<xsl:choose>
 			<xsl:when test="@frames"><xsl:value-of select="@frames"/></xsl:when>
+			<xsl:when test="frame"><xsl:value-of select="count(frame)"/></xsl:when>
 			<xsl:otherwise>1</xsl:otherwise>
 		</xsl:choose>
 	</xsl:variable>

data/ext/swfmill/test/Makefile.in

@@ -80,12 +80,13 @@ ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
+EXSLT_CFLAGS = @EXSLT_CFLAGS@
+EXSLT_LIBS = @EXSLT_LIBS@
 F77 = @F77@
 FFLAGS = @FFLAGS@
 FREETYPE_CFLAGS = @FREETYPE_CFLAGS@
 FREETYPE_LIBS = @FREETYPE_LIBS@
 GREP = @GREP@
-HAVE_PKGCONFIG = @HAVE_PKGCONFIG@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@

data/ext/swfmill/test/xml/Makefile.in

@@ -68,12 +68,13 @@ ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
+EXSLT_CFLAGS = @EXSLT_CFLAGS@
+EXSLT_LIBS = @EXSLT_LIBS@
 F77 = @F77@
 FFLAGS = @FFLAGS@
 FREETYPE_CFLAGS = @FREETYPE_CFLAGS@
 FREETYPE_LIBS = @FREETYPE_LIBS@
 GREP = @GREP@
-HAVE_PKGCONFIG = @HAVE_PKGCONFIG@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@

data/ext/swfmill_ext.cc

@@ -1,375 +1,21 @@
-#include <zlib.h>
 #include "ruby.h"
-#include "SWF.h"
-#include "SWFReader.h"
-#include "SWFWriter.h"
+#include "swfmill_ext_to_xml.h"
+#include "swfmill_ext_to_swf.h"
 
-static VALUE rb_mSwfmill;
-static VALUE rb_eSwfmill_Error;
-static VALUE rb_eSwfmill_EOFError;
+VALUE rb_mSwfmill;
+VALUE rb_eSwfmill_Error;
+VALUE rb_eSwfmill_EOFError;
 
-/*
-  call-seq:
-    Swfmill.to_xmlstr(str [, params]) -> String
-
-  +params+
-    {
-      :version => Fixnum,
-      :compressed => Boolean,
-    }
- */
-VALUE swfmill_ext_to_xmlstr(int argc, VALUE *argv, VALUE self)
-{
-    VALUE arg_str, arg_param;
-    int arg_num = rb_scan_args(argc, argv, "11", &arg_str, &arg_param);
-
-    unsigned char version = 7;
-    bool       compressed = false;
-
-    Check_Type(arg_str, T_STRING);
-    if(arg_num == 2)
-    {
-        Check_Type(arg_param, T_HASH);
-
-        VALUE ver = rb_hash_aref(arg_param, ID2SYM(rb_intern("version")));
-        if(!NIL_P(ver))
-        {
-            version = (unsigned char)NUM2INT(ver);
-        }
-
-        VALUE cmp = rb_hash_aref(arg_param, ID2SYM(rb_intern("compressed")));
-        if(!NIL_P(cmp))
-        {
-            compressed = cmp == Qtrue;
-        }
-    }
-
-    unsigned char* data = (unsigned char*)StringValuePtr(arg_str);
-    size_t         size = RSTRING_LEN(arg_str);
-
-    SWF::Header header;
-    {
-        SWF::Context context;
-        SWF::Reader reader(data, size);
-        header.parse(&reader, size, &context);
-        switch(reader.getError())
-        {
-        case SWFR_ERROR:
-            rb_raise(rb_eSwfmill_Error, "unknown error while reading SWF");
-            break;
-        case SWFR_EOF:
-            rb_raise(rb_eSwfmill_EOFError, "reached EOF while reading SWF");
-            break;
-        }
-    }
-
-    VALUE xml = Qnil;
-    {
-        SWF::Context context;
-        xmlDocPtr  doc  = xmlNewDoc((const xmlChar*)"1.0");
-        xmlNodePtr root = doc->xmlRootNode = xmlNewDocNode(doc, NULL, (const xmlChar *)"swf", NULL);
-        char       tmp[4];
-
-        snprintf(tmp, sizeof(tmp), "%i", version);
-        xmlSetProp(root, (const xmlChar*)"version", (const xmlChar*)tmp);
-
-        snprintf(tmp, sizeof(tmp), "%i", compressed?1:0);
-        xmlSetProp(root, (const xmlChar*)"compressed", (const xmlChar*)tmp);
-
-        context.swfVersion = version;
-        header.writeXML(root, &context);
-
-        char* xml_data = NULL;
-        int   xml_size;
-        xmlDocDumpFormatMemory(doc, (xmlChar **)&xml_data, &xml_size, 1);
-
-        if(xml_size > 0)
-        {
-            xml = rb_str_new(xml_data, xml_size);
-        }
-
-        if(xml_data != NULL)
-        {
-            xmlFree(xml_data);
-        }
-
-        xmlFreeDoc(doc);
-    }
-
-    return xml;
-}
-
-/*
-  call-seq:
-    Swfmill.to_swf(str [, params]) -> Array
-
-  +params+
-    {
-      :compress => Boolean,
-      :level => Symbol,
-    }
-
-  :compress
-    true
-    false
-    nil
+extern "C" {
 
-  :level
-    :best
-    :speed
-    :none
- */
-VALUE swfmill_ext_to_swf(int argc, VALUE *argv, VALUE self)
+void Init_swfmill_ext(void)
 {
-    VALUE arg_str, arg_param;
-    int arg_num = rb_scan_args(argc, argv, "11", &arg_str, &arg_param);
-
-    unsigned char version = 7;
-    bool       compressed = false;
-    int          compress = 0;
-    int    compress_level = Z_BEST_COMPRESSION;
-
-    Check_Type(arg_str, T_STRING);
-    if(arg_num == 2)
-    {
-        Check_Type(arg_param, T_HASH);
-
-        VALUE lvl = rb_hash_aref(arg_param, ID2SYM(rb_intern("level")));
-        if(!NIL_P(lvl))
-        {
-            if(lvl == ID2SYM(rb_intern("speed")))
-            {
-                compress_level = Z_BEST_SPEED;
-            }
-            if(lvl == ID2SYM(rb_intern("none")))
-            {
-                compress_level = Z_NO_COMPRESSION;
-            }
-        }
-
-        VALUE cmp = rb_hash_aref(arg_param, ID2SYM(rb_intern("compressed")));
-        if(!NIL_P(cmp))
-        {
-            compress = cmp == Qtrue ? 1 : 2;
-        }
-    }
+    rb_mSwfmill = rb_define_module("Swfmill");
+    rb_eSwfmill_Error = rb_define_class_under(rb_mSwfmill, "Error", rb_eStandardError);
+    rb_eSwfmill_EOFError = rb_define_class_under(rb_mSwfmill, "EOFError", rb_eStandardError);
 
-    char*      data = StringValuePtr(arg_str);
-    int        size = RSTRING_LEN(arg_str);
-    xmlDocPtr  doc  = xmlParseMemory(data, size);
-
-    if(doc == NULL)
-    {
-        rb_raise(rb_eSwfmill_Error, "XML parser error");
-    }
-
-    xmlNodePtr root = doc->xmlRootNode;
-    if(strcmp((const char*)root->name, "swf") != 0)
-    {
-        xmlFreeDoc(doc);
-        rb_raise(rb_eSwfmill_Error, "doesn't seem to be a swfml file");
-    }
-
-    xmlNodePtr headerNode = root->children;
-	while((headerNode != NULL) &&
-          (headerNode->name == NULL || strcmp((const char*)headerNode->name, "Header") != 0))
-    {
-		headerNode = headerNode->next;
-	}
-    if(headerNode == NULL)
-    {
-        xmlFreeDoc(doc);
-        rb_raise(rb_eSwfmill_Error, "swfml file is empty");
-    }
-
-    {
-        xmlChar *tmp;
-        tmp = xmlGetProp(root, (const xmlChar*)"version");
-        if(tmp != NULL)
-        {
-            int i;
-            sscanf((char*)tmp, "%i", &i);
-            version = i;
-            xmlFree(tmp);
-        }
-
-        tmp = xmlGetProp(root, (const xmlChar*)"compressed");
-        if(tmp != NULL)
-        {
-            int i;
-            sscanf((char*)tmp, "%i", &i);
-            compressed = i > 0;
-            xmlFree(tmp);
-        }
-    }
-    if(compress > 0)
-    {
-        compressed = compress == 1;
-    }
-
-    SWF::Header header;
-    size_t swf_size;
-    {
-        SWF::Context context;
-        context.swfVersion = version;
-        header.parseXML(headerNode, &context);
-        swf_size = header.getSize(&context, 0) / 8;
-    }
-
-    char swf_head[8+1];
-    {
-        swf_size += 8;
-        snprintf(swf_head, 8, "%s%c%c%c%c%c",
-                 compressed ? "CWS" : "FWS",
-                 version,
-                 ((swf_size>> 0) & 0xFF),
-                 ((swf_size>> 8) & 0xFF),
-                 ((swf_size>>16) & 0xFF),
-                 ((swf_size>>24) & 0xFF));
-        swf_size -= 8;
-    }
-
-    unsigned char* swf_buff = (unsigned char*)ruby_xmalloc(swf_size);
-    {
-        SWF::Context context;
-        SWF::Writer writer(swf_buff, swf_size);
-        context.swfVersion = version;
-        header.write(&writer, &context);
-        switch(writer.getError())
-        {
-        case SWFW_ERROR:
-            ruby_xfree(swf_buff);
-            xmlFreeDoc(doc);
-            rb_raise(rb_eSwfmill_Error, "unknown write error");
-            break;
-        case SWFW_FULL:
-            ruby_xfree(swf_buff);
-            xmlFreeDoc(doc);
-            rb_raise(rb_eSwfmill_Error, "write buffer full");
-            break;
-        }
-    }
-
-    if(compressed)
-    {
-        unsigned char temp[BUFSIZ];
-        z_stream stream={Z_NULL};
-        int status, count;
-
-        unsigned char* out_buff = (unsigned char*)ruby_xmalloc(swf_size);
-        int out_offset = 0, out_size = swf_size;
-
-        stream.next_in   = swf_buff;
-        stream.avail_in  = swf_size;
-        stream.next_out  = temp;
-        stream.avail_out = BUFSIZ;
-
-        status = deflateInit(&stream, compress_level);
-        if(status != Z_OK)
-        {
-            ruby_xfree(swf_buff);
-            xmlFreeDoc(doc);
-            rb_raise(rb_eSwfmill_Error, "Error compressing SWF: %s", stream.msg);
-        }
-
-        for(;;)
-        {
-            if(stream.avail_in == 0)
-            {
-                break;
-            }
-
-            status = deflate(&stream, Z_NO_FLUSH);
-            if(status != Z_OK)
-            {
-                ruby_xfree(swf_buff);
-                xmlFreeDoc(doc);
-                rb_raise(rb_eSwfmill_Error, "Error compressing SWF: %s", stream.msg);
-            }
-
-            count = BUFSIZ - stream.avail_out;
-            if(count > 0)
-            {
-                if(out_offset + count >= out_size)
-                {
-                    int tmp_size = out_size + out_size / 2;
-                    unsigned char* tmp_buff = (unsigned char*)ruby_xmalloc(tmp_size);
-                    memcpy(tmp_buff, out_buff, out_size);
-                    ruby_xfree(out_buff);
-                    out_buff = tmp_buff;
-                    out_size = tmp_size;
-                }
-                memcpy(out_buff + out_offset, temp, count);
-                out_offset += count;
-            }
-
-            stream.next_out  = temp;
-            stream.avail_out = BUFSIZ;
-        }
-
-        do
-        {
-            status = deflate(&stream, Z_FINISH);
-
-            count = BUFSIZ - stream.avail_out;
-            if(count > 0)
-            {
-                if(out_offset + count >= out_size)
-                {
-                    int tmp_size = out_size + out_size / 2;
-                    unsigned char* tmp_buff = (unsigned char*)ruby_xmalloc(tmp_size);
-                    memcpy(tmp_buff, out_buff, out_size);
-                    ruby_xfree(out_buff);
-                    out_buff = tmp_buff;
-                    out_size = tmp_size;
-                }
-                memcpy(out_buff + out_offset, temp, count);
-                out_offset += count;
-            }
-
-            stream.next_out  = temp;
-            stream.avail_out = BUFSIZ;
-        } while(status == Z_OK);
-
-        if(status != Z_STREAM_END)
-        {
-            ruby_xfree(swf_buff);
-            xmlFreeDoc(doc);
-            rb_raise(rb_eSwfmill_Error, "Error compressing SWF: %s", stream.msg);
-        }
-
-        status = deflateEnd(&stream);
-        if(status != Z_OK)
-        {
-            ruby_xfree(swf_buff);
-            xmlFreeDoc(doc);
-            rb_raise(rb_eSwfmill_Error, "Error compressing SWF: %s", stream.msg);
-        }
-
-        ruby_xfree(swf_buff);
-        swf_size = out_offset;
-        swf_buff = (unsigned char*)ruby_xmalloc(swf_size);
-        memcpy(swf_buff, out_buff, swf_size);
-        ruby_xfree(out_buff);
-    }
-
-    VALUE swf;
-    swf = rb_str_new(swf_head, 8);
-    rb_str_cat(swf, (const char*)swf_buff, swf_size);
-
-    ruby_xfree(swf_buff);
-    xmlFreeDoc(doc);
-    return swf;
+    rb_define_singleton_method(rb_mSwfmill, "to_xml", (VALUE (*)(...))swfmill_ext_to_xml, 2);
+    rb_define_singleton_method(rb_mSwfmill, "to_swf", (VALUE (*)(...))swfmill_ext_to_swf, 2);
 }
 
-extern "C" {
-    void Init_swfmill_ext(void)
-    {
-        rb_mSwfmill = rb_define_module("Swfmill");
-        rb_define_singleton_method(rb_mSwfmill, "to_xmlstr", (VALUE(*)(...))swfmill_ext_to_xmlstr, -1);
-        rb_define_singleton_method(rb_mSwfmill, "to_swf", (VALUE(*)(...))swfmill_ext_to_swf, -1);
-
-        rb_eSwfmill_Error = rb_define_class_under(rb_mSwfmill, "Error", rb_eStandardError);
-        rb_eSwfmill_EOFError = rb_define_class_under(rb_mSwfmill, "EOFError", rb_eStandardError);
-    }
 }

data/ext/swfmill_ext_to_swf.cc

@@ -0,0 +1,260 @@
+#include <zlib.h>
+#include "ruby.h"
+#include "SWF.h"
+#include "SWFWriter.h"
+#include "deflate.h"
+
+extern VALUE rb_eSwfmill_Error;
+extern VALUE rb_eSwfmill_EOFError;
+
+#define SIGNATURE_SIZE 8
+typedef struct {
+    VALUE            string;
+    VALUE          encoding;
+    bool         compressed;
+    SWF::Header     *header;
+    SWF::Context   *context;
+    size_t         datasize;
+    unsigned char *databuff;
+    int      compress_level;
+    xmlDocPtr      document;
+    xmlNodePtr    root_node;
+    xmlNodePtr  header_node;
+} swfmill_to_swf;
+
+static void
+sts_mark(swfmill_to_swf * const sts)
+{
+    if(sts != NULL)
+    {
+        rb_gc_mark(sts->string);
+        rb_gc_mark(sts->encoding);
+    }
+}
+
+static void
+sts_free(swfmill_to_swf * const sts)
+{
+    if(sts != NULL)
+    {
+        if(sts->document != NULL)
+        {
+            xmlFreeDoc(sts->document);
+            sts->document = NULL;
+        }
+
+        ruby_xfree(sts->databuff);
+        sts->databuff = NULL;
+
+        delete sts->header;
+        sts->header = NULL;
+
+        delete sts->context;
+        sts->context = NULL;
+    }
+}
+
+static bool
+sts_parse_document(swfmill_to_swf * const sts)
+{
+    sts->document = xmlParseMemory(RSTRING_PTR(sts->string), RSTRING_LEN(sts->string));
+    if(sts->document == NULL)
+    {
+        rb_raise(rb_eSwfmill_Error, "XML parser error");
+        return false;
+    }
+
+    sts->root_node = sts->document->xmlRootNode;
+    if(strcmp((const char*)sts->root_node->name, "swf") != 0)
+    {
+        rb_raise(rb_eSwfmill_Error, "doesn't seem to be a swfml file");
+        return false;
+    }
+
+    return true;
+}
+
+static bool
+sts_search_header_node(swfmill_to_swf * const sts)
+{
+    xmlNodePtr headerNode = sts->root_node->children;
+
+    while((headerNode != NULL) &&
+          (headerNode->name == NULL || strcmp((const char*)headerNode->name, "Header") != 0))
+    {
+        headerNode = headerNode->next;
+    }
+
+    if(headerNode == NULL)
+    {
+        rb_raise(rb_eSwfmill_Error, "swfml file is empty");
+        return false;
+    }
+
+    sts->header_node = headerNode;
+
+    return true;
+}
+
+static void
+sts_get_version(swfmill_to_swf * const sts)
+{
+    xmlChar *tmp = xmlGetProp(sts->root_node, (const xmlChar*)"version");
+
+    sts->context = new SWF::Context;
+    sts->context->debugTrace = false;
+    sts->context->quiet      = true;
+
+    if(tmp != NULL)
+    {
+        sscanf((char*)tmp, "%i", &sts->context->swfVersion);
+        xmlFree(tmp);
+    }
+}
+
+static void
+sts_get_compressed(swfmill_to_swf * const sts)
+{
+    xmlChar *tmp = xmlGetProp(sts->root_node, (const xmlChar*)"compressed");
+    int compress;
+
+    sts->compressed = false;
+    if(tmp != NULL)
+    {
+        sscanf((char*)tmp, "%i", &compress);
+        sts->compressed = compress > 0;
+        xmlFree(tmp);
+    }
+}
+
+static void
+sts_parse_xml(swfmill_to_swf * const sts)
+{
+    sts->context->convertEncoding = true;
+    sts->context->swf_encoding = StringValueCStr(sts->encoding);
+
+    sts->header = new SWF::Header;
+    sts->header->parseXML(sts->header_node, sts->context);
+
+    sts->datasize = sts->header->getSize(sts->context, 0) / 8;
+    sts->databuff = (unsigned char*)ruby_xmalloc(sts->datasize + SIGNATURE_SIZE);
+}
+
+static bool
+sts_compress(swfmill_to_swf * const sts)
+{
+    if(!sts->compressed)
+    {
+        return true;
+    }
+
+    Deflate deflate(sts->databuff + SIGNATURE_SIZE, sts->datasize, sts->compress_level);
+
+    if(!deflate.compress())
+    {
+        rb_raise(rb_eSwfmill_Error, "compressing SWF: %s", deflate.error());
+        return false;
+    }
+
+    ruby_xfree(sts->databuff);
+    sts->databuff = NULL;
+
+    sts->datasize = deflate.size();
+    sts->databuff = (unsigned char*)ruby_xmalloc(sts->datasize + SIGNATURE_SIZE);
+    memcpy(sts->databuff + SIGNATURE_SIZE, deflate.data(), sts->datasize);
+
+    return true;
+}
+
+static bool
+sts_write(swfmill_to_swf * const sts)
+{
+    SWF::Writer writer(sts->databuff + SIGNATURE_SIZE, sts->datasize);
+    size_t    datasize;
+
+    sts->header->write(&writer, sts->context);
+    switch(writer.getError())
+    {
+    case SWFW_ERROR:
+        rb_raise(rb_eSwfmill_Error, "unknown write error");
+        return false;
+    case SWFW_FULL:
+        rb_raise(rb_eSwfmill_Error, "write buffer full");
+        return false;
+    }
+
+    if(!sts_compress(sts))
+    {
+        return false;
+    }
+
+    sts->databuff[0] = (unsigned char)(sts->compressed ? 'C' : 'F');
+    sts->databuff[1] = (unsigned char)'W';
+    sts->databuff[2] = (unsigned char)'S';
+    sts->databuff[3] = (unsigned char)sts->context->swfVersion;
+
+    datasize = sts->datasize;
+    sts->databuff[4] = (unsigned char)((datasize >>  0) & 0xFF);
+    sts->databuff[5] = (unsigned char)((datasize >>  8) & 0xFF);
+    sts->databuff[6] = (unsigned char)((datasize >> 16) & 0xFF);
+    sts->databuff[7] = (unsigned char)((datasize >> 24) & 0xFF);
+
+    return true;
+}
+
+static bool
+sts_parse(swfmill_to_swf * const sts)
+{
+    if(!sts_parse_document(sts))
+    {
+        return false;
+    }
+    if(!sts_search_header_node(sts))
+    {
+        return false;
+    }
+    sts_get_version(sts);
+    sts_get_compressed(sts);
+    sts_parse_xml(sts);
+    if(!sts_write(sts))
+    {
+        return false;
+    }
+    return true;
+}
+
+static VALUE
+sts_to_string(swfmill_to_swf * const sts)
+{
+    VALUE str = rb_str_new((const char*)sts->databuff, sts->datasize + SIGNATURE_SIZE);
+
+    ruby_xfree(sts->databuff);
+    sts->databuff = NULL;
+
+    return str;
+}
+
+/*
+  call-seq:
+    Swfmill.to_swf(str, encoding) -> String
+ */
+VALUE swfmill_ext_to_swf(VALUE self, VALUE string, VALUE encoding)
+{
+    swfmill_to_swf *sts;
+
+    Check_Type(string, T_STRING);
+    Check_Type(encoding, T_STRING);
+
+    Data_Make_Struct(rb_cData, swfmill_to_swf, sts_mark, sts_free, sts);
+
+    sts->string         = string;
+    sts->encoding       = encoding;
+    sts->compress_level = Z_BEST_COMPRESSION;
+
+    if(sts_parse(sts))
+    {
+        return sts_to_string(sts);
+    }
+
+    return Qnil;
+}