swfmill 0.0.1 → 0.0.2

data/ext/swfmill_ext_to_swf.h

@@ -0,0 +1,6 @@
+#ifndef _SWFMILL_EXT_TO_SWF_H_
+#define _SWFMILL_EXT_TO_SWF_H_
+
+VALUE swfmill_ext_to_swf(VALUE, VALUE, VALUE);
+
+#endif /* _SWFMILL_EXT_TO_SWF_H_ */

data/ext/swfmill_ext_to_xml.cc

@@ -0,0 +1,262 @@
+#include "ruby.h"
+#include "SWF.h"
+#include "SWFReader.h"
+#include "inflate.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;
+} swfmill_to_xml;
+
+static void
+stx_mark(swfmill_to_xml * const stx)
+{
+    if(stx != NULL)
+    {
+        rb_gc_mark(stx->string);
+        rb_gc_mark(stx->encoding);
+    }
+}
+
+static void
+stx_free(swfmill_to_xml * const stx)
+{
+    if(stx != NULL)
+    {
+        delete stx->header;
+        stx->header = NULL;
+        delete stx->context;
+        stx->context = NULL;
+    }
+}
+
+static bool
+stx_validate(const swfmill_to_xml * const stx)
+{
+    if((RSTRING_LEN(stx->string) < SIGNATURE_SIZE) ||
+       (strncmp(RSTRING_PTR(stx->string), "CWS", 2) != 0 &&
+        strncmp(RSTRING_PTR(stx->string), "FWS", 2) != 0))
+    {
+        rb_raise(rb_eSwfmill_Error, "input is no SWF");
+        return false;
+    }
+    return true;
+}
+
+static void
+stx_check_version(swfmill_to_xml * const stx)
+{
+    stx->context = new SWF::Context;
+    stx->context->debugTrace = false;
+    stx->context->quiet      = true;
+
+    stx->context->swfVersion = (int)RSTRING_PTR(stx->string)[3];
+    // fprintf(stderr, "swfVersion: %d\n", stx->context->swfVersion);
+}
+
+static void
+stx_check_compressed(swfmill_to_xml * const stx)
+{
+    stx->compressed = RSTRING_PTR(stx->string)[0] == 'C';
+    // fprintf(stderr, "compressed: %d\n", stx->compressed);
+}
+
+static void
+stx_check_datasize(swfmill_to_xml * const stx)
+{
+    stx->datasize  = (size_t)RSTRING_PTR(stx->string)[4];
+    stx->datasize += (size_t)RSTRING_PTR(stx->string)[5] << 8;
+    stx->datasize += (size_t)RSTRING_PTR(stx->string)[6] << 16;
+    stx->datasize += (size_t)RSTRING_PTR(stx->string)[7] << 24;
+    // fprintf(stderr, "datasize: %d\n", stx->datasize);
+
+    if(stx->datasize != RSTRING_LEN(stx->string) - SIGNATURE_SIZE)
+    {
+        if((!stx->compressed) &&
+           (stx->datasize > RSTRING_LEN(stx->string) - SIGNATURE_SIZE))
+        {
+            stx->datasize = RSTRING_LEN(stx->string) - SIGNATURE_SIZE;
+        }
+    }
+    // fprintf(stderr, "fixed datasize: %d\n", stx->datasize);
+}
+
+static bool
+stx_copy(swfmill_to_xml * const stx)
+{
+    stx->string = rb_str_new(RSTRING_PTR(stx->string) + SIGNATURE_SIZE,
+                             RSTRING_LEN(stx->string) - SIGNATURE_SIZE);
+    return true;
+}
+
+static bool
+stx_decompress(swfmill_to_xml * const stx)
+{
+    if(!stx->compressed)
+    {
+        return stx_copy(stx);
+    }
+
+    const unsigned char* buff = (const unsigned char*)RSTRING_PTR(stx->string) + SIGNATURE_SIZE;
+    const size_t         size = RSTRING_LEN(stx->string) -  SIGNATURE_SIZE;
+    Inflate inflate(buff, size, stx->datasize);
+
+    if(!inflate.decompress())
+    {
+        rb_raise(rb_eSwfmill_Error, "decompressing SWF");
+        return false;
+    }
+
+    stx->string = rb_str_new((const char*)inflate.data(), stx->datasize);
+
+    return true;
+}
+
+static bool
+stx_read(swfmill_to_xml* const stx)
+{
+    SWF::Reader reader((const unsigned char*)RSTRING_PTR(stx->string), RSTRING_LEN(stx->string));
+
+    stx->header = new SWF::Header;
+    stx->header->parse(&reader, RSTRING_LEN(stx->string), stx->context);
+
+    switch(reader.getError())
+    {
+    case SWFR_ERROR:
+        rb_raise(rb_eSwfmill_Error, "unknown error while reading SWF");
+        return false;
+    case SWFR_EOF:
+        rb_raise(rb_eSwfmill_EOFError, "reached EOF while reading SWF");
+        return false;
+    }
+
+    return true;
+}
+
+static bool
+stx_parse(swfmill_to_xml* const stx)
+{
+    if(!stx_validate(stx))
+    {
+        return false;
+    }
+    stx_check_version(stx);
+    stx_check_compressed(stx);
+    stx_check_datasize(stx);
+    if(!stx_decompress(stx))
+    {
+        return false;
+    }
+    if(!stx_read(stx))
+    {
+        return false;
+    }
+    return true;
+}
+
+static void
+stx_init_xml_memory()
+{
+    xmlMemSetup((xmlFreeFunc)ruby_xfree,
+                (xmlMallocFunc)ruby_xmalloc,
+                (xmlReallocFunc)ruby_xrealloc,
+                strdup);
+}
+
+static void
+stx_set_version_proparty(const swfmill_to_xml* const stx, xmlNodePtr root)
+{
+    char temp[4];
+    snprintf(temp, sizeof(temp), "%i", stx->context->swfVersion);
+    xmlSetProp(root, (const xmlChar*)"version", (const xmlChar*)temp);
+}
+
+static void
+stx_set_compressed_proparty(const swfmill_to_xml* const stx, xmlNodePtr root)
+{
+    char temp[4];
+    snprintf(temp, sizeof(temp), "%i", stx->compressed ? 1 : 0);
+    xmlSetProp(root, (const xmlChar*)"compressed", (const xmlChar*)temp);
+}
+
+static void
+stx_set_encoding(swfmill_to_xml* const stx)
+{
+    stx->context->convertEncoding = true;
+    stx->context->swf_encoding    = StringValueCStr(stx->encoding);
+    // fprintf(stderr, "%s\n", stx->context->swf_encoding);
+}
+
+static VALUE
+stx_dump(const swfmill_to_xml* const stx, xmlDocPtr doc)
+{
+    VALUE      xml = Qnil;
+    char* xml_data = NULL;
+    int   xml_size = 0;
+
+    xmlDocDumpMemoryEnc(doc, (xmlChar**)&xml_data, &xml_size, "UTF-8");
+    if(xml_size > 0)
+    {
+        xml = rb_str_new(xml_data, xml_size);
+    }
+    if(xml_data != NULL)
+    {
+        xmlFree(xml_data);
+    }
+    return xml;
+}
+
+static VALUE
+stx_to_string(swfmill_to_xml* const stx)
+{
+    VALUE       xml = Qnil;
+    xmlDocPtr   doc;
+    xmlNodePtr root;
+    stx_init_xml_memory();
+
+    doc  = xmlNewDoc((const xmlChar*)"1.0");
+    root = doc->xmlRootNode = xmlNewDocNode(doc, NULL, (const xmlChar*)"swf", NULL);
+
+    stx_set_version_proparty(stx, root);
+    stx_set_compressed_proparty(stx, root);
+    stx_set_encoding(stx);
+
+    stx->header->writeXML(root, stx->context);
+    xml = stx_dump(stx, doc);
+
+    xmlFreeDoc(doc);
+    return xml;
+}
+
+/*
+  call-seq:
+    Swfmill.to_xml(string, encoding) -> String
+ */
+VALUE
+swfmill_ext_to_xml(VALUE self, VALUE string, VALUE encoding)
+{
+    swfmill_to_xml *stx;
+
+    Check_Type(string, T_STRING);
+    Check_Type(encoding, T_STRING);
+
+    Data_Make_Struct(rb_cData, swfmill_to_xml, stx_mark, stx_free, stx);
+
+    stx->string   = string;
+    stx->encoding = encoding;
+
+    if(stx_parse(stx))
+    {
+        return stx_to_string(stx);
+    }
+
+    return Qnil;
+}

data/ext/swfmill_ext_to_xml.h

@@ -0,0 +1,6 @@
+#ifndef _SWFMILL_EXT_TO_XML_H_
+#define _SWFMILL_EXT_TO_XML_H_
+
+VALUE swfmill_ext_to_xml(VALUE, VALUE, VALUE);
+
+#endif /* _SWFMILL_EXT_TO_XML_H_ */

data/ext/test/Makefile

@@ -0,0 +1,16 @@
+OBJS = buffer_test.o inflate_test.o deflate_test.o
+
+CXX     = g++
+CFLAGS  = -g -O0 -I../ -I$(HOME)/include
+LDFLAGS = -L$(HOME)/lib -lgtest_main -lz -lpthread
+
+all: $(OBJS)
+	$(CXX) $(CFLAGS) $(LDFLAGS) -o test_all $(OBJS)
+	./test_all || rm ./test_all
+
+.cc.o:
+	$(CXX) $(CFLAGS) -c $<
+
+PHONY: check-syntax
+check-syntax:
+	$(CXX) $(CFLAGS) -Wall -Wextra -pedantic -fsyntax-only $(CHK_SOURCES)

data/ext/test/buffer_test.cc

@@ -0,0 +1,84 @@
+#include <gtest/gtest.h>
+#include "buffer.h"
+
+class BufferTest : public testing::Test
+{
+};
+
+TEST_F(BufferTest, Constructor)
+{
+    buffer<char> temp(1);
+}
+
+TEST_F(BufferTest, CopyConstructor)
+{
+    buffer<char> tmp1(5);
+    tmp1.append("54321", 5);
+
+    buffer<char> tmp2 = tmp1;
+    ASSERT_EQ(0, memcmp("54321", tmp2.ptr(), tmp2.size()));
+}
+
+TEST_F(BufferTest, Ptr)
+{
+    buffer<char> temp(1);
+    ASSERT_TRUE(temp.ptr() != NULL);
+}
+
+TEST_F(BufferTest, Size)
+{
+    buffer<char> temp(1);
+    ASSERT_EQ(0, temp.size());
+}
+
+TEST_F(BufferTest, Capacity)
+{
+    buffer<char> temp(1);
+    ASSERT_EQ(1, temp.capacity());
+}
+
+TEST_F(BufferTest, Raise_Capacity)
+{
+    buffer<char> tmp1(4);
+
+    tmp1.append("12345", 5);
+    EXPECT_EQ(5, tmp1.size());
+    EXPECT_EQ(11, tmp1.capacity());
+
+    buffer<char> tmp2(2);
+
+    tmp2.append("12345", 5);
+    EXPECT_EQ(5, tmp2.size());
+    EXPECT_EQ(9, tmp2.capacity());
+}
+
+TEST_F(BufferTest, Append)
+{
+    const char* data = "abc";
+    buffer<char> temp;
+
+    ASSERT_EQ(3, temp.append(data, strlen(data)));
+    ASSERT_EQ(0, memcmp(data, temp.ptr(), temp.size()));
+}
+
+TEST_F(BufferTest, Reserve)
+{
+    buffer<char> temp(3);
+    temp.append("1234", 4);
+    ASSERT_EQ(3, temp.reserve(3));
+    ASSERT_EQ(3, temp.size());
+    ASSERT_EQ(3, temp.capacity());
+    ASSERT_EQ(0, memcmp("123", temp.ptr(), temp.size()));
+}
+
+TEST_F(BufferTest, Resize)
+{
+    buffer<char> temp(5);
+
+    temp.append("12345", 5);
+    temp.resize(3);
+    ASSERT_EQ(0, memcmp("123", temp.ptr(), temp.size()));
+
+    temp.resize(10);
+    ASSERT_EQ(12, temp.capacity());
+}

data/ext/test/deflate_test.cc

@@ -0,0 +1,61 @@
+#include <iostream>
+#include <fstream>
+#include <gtest/gtest.h>
+#include "deflate.h"
+
+class DeflateTest : public testing::Test
+{
+protected:
+
+    void SetUp()
+    {
+        read_file("test.dat", testdata, testdata_size);
+        testdata_length = 256;
+
+        testbuff = new unsigned char[testdata_length];
+        for(size_t i=0; i<testdata_length; i++)
+        {
+            testbuff[i] = i;
+        }
+    }
+
+    void TearDown()
+    {
+        delete[] testdata;
+        delete[] testbuff;
+    }
+
+    void read_file(const char* const filename, char*& data, size_t& length)
+    {
+        std::ifstream is;
+
+        is.open(filename, std::ios::binary);
+
+        is.seekg(0, std::ios::end);
+        length = is.tellg();
+        is.seekg(0, std::ios::beg);
+
+        data = new char[length];
+        is.read(data, length);
+        is.close();
+    }
+
+    char*  testdata;
+    size_t testdata_size;
+    size_t testdata_length;
+    unsigned char* testbuff;
+
+};
+
+TEST_F(DeflateTest, Constructor)
+{
+    Deflate d((unsigned char*)testdata, testdata_size);
+}
+
+TEST_F(DeflateTest, compress)
+{
+    Deflate d(testbuff, testdata_length);
+    EXPECT_TRUE(d.compress());
+    ASSERT_TRUE(memcmp(d.data(), testdata, testdata_length) == 0);
+    ASSERT_EQ(testdata_size, d.size());
+}

data/ext/test/inflate_test.cc

@@ -0,0 +1,84 @@
+#include <iostream>
+#include <fstream>
+#include <gtest/gtest.h>
+#include "inflate.h"
+
+class InflateTest : public testing::Test
+{
+protected:
+
+    void SetUp()
+    {
+        read_file("test.dat", testdata, testdata_size);
+        testdata_length = 256;
+    }
+
+    void TearDown()
+    {
+        delete[] testdata;
+    }
+
+    void read_file(const char* const filename, char*& data, size_t& length)
+    {
+        std::ifstream is;
+
+        is.open(filename, std::ios::binary);
+
+        is.seekg(0, std::ios::end);
+        length = is.tellg();
+        is.seekg(0, std::ios::beg);
+
+        data = new char[length];
+        is.read(data, length);
+        is.close();
+    }
+
+    char*  testdata;
+    size_t testdata_size;
+    size_t testdata_length;
+
+};
+
+TEST_F(InflateTest, Constructor)
+{
+    Inflate i((unsigned char*)testdata, testdata_size, testdata_length);
+}
+
+TEST_F(InflateTest, data)
+{
+    Inflate i((unsigned char*)testdata, testdata_size, testdata_length);
+    ASSERT_TRUE(i.data() != NULL);
+}
+
+TEST_F(InflateTest, decompress)
+{
+    Inflate i((unsigned char*)testdata, testdata_size, testdata_length);
+    ASSERT_TRUE(i.decompress());
+}
+
+TEST_F(InflateTest, decompress_1)
+{
+    Inflate i((unsigned char*)testdata, testdata_size, testdata_length);
+    EXPECT_TRUE(i.decompress());
+
+    const unsigned char f[] = {0,1,2,3,4,5,6,7,8,9};
+    ASSERT_TRUE(memcmp(i.data(), f, 10) == 0);
+}
+
+TEST_F(InflateTest, decompress_2)
+{
+    Inflate i(NULL, testdata_size, testdata_length);
+    ASSERT_FALSE(i.decompress());
+}
+
+TEST_F(InflateTest, decompress_3)
+{
+    Inflate i((unsigned char*)testdata, testdata_size - 1, testdata_length);
+    ASSERT_FALSE(i.decompress());
+}
+
+TEST_F(InflateTest, decompress_4)
+{
+    Inflate i((unsigned char*)testdata, testdata_size, testdata_length - 1);
+    ASSERT_FALSE(i.decompress());
+}