swf_converter 0.0.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://www.rubygems.org/'
+
+gemspec
+

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/check_memory.rb

@@ -0,0 +1,41 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'swf_converter'
+
+class MemoryCheckEngine < SwfConverter::Engine::Alphize
+  def blend(*args)
+    puts "About to blend"
+    super
+    puts "Blended"
+  end
+end
+
+class Swf
+  include SwfConverter
+
+  attr_reader :swf_image_path
+
+  converts_swfs :with => MemoryCheckEngine, :size => [600, 600]
+
+  def initialize(swf_image_path)
+    @swf_image_path = swf_image_path
+  end
+
+  def local_swf_path
+    File.expand_path(File.join('..', 'examples', 'balloon.swf'), __FILE__)
+  end
+end
+
+3.times do |major_iteration|
+  5.times do |minor_iteration|
+    file = Tempfile.new('check_memory')
+    swf = Swf.new(file.path)
+    puts swf.local_swf_path
+    swf.convert_swf!
+    file.close!
+    puts "Finished #{3 * major_iteration + minor_iteration}"
+  end
+  puts "Enter?";gets
+end
+puts "All done!";gets
+

data/lib/swf_converter.rb

@@ -0,0 +1,26 @@
+require 'swf_converter/engine/alphize'
+
+module SwfConverter
+  module ClassMethods
+    attr_reader :swf_conversion_engine, :swf_conversion_options
+
+    def converts_swfs(options={})
+      options = options.dup
+      engine_class = options.delete(:with)
+      @swf_conversion_engine = engine_class.new if engine_class
+      @swf_conversion_engine.options = options
+    end
+  end
+
+  def convert_swf!
+    self.class.swf_conversion_engine.convert!(self)
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.converts_swfs :with => Engine::Alphize
+  end
+
+  class InvalidOptions < RuntimeError; end
+end
+

data/lib/swf_converter/engine.rb

@@ -0,0 +1,24 @@
+require 'swf_converter'
+
+require 'swf_converter/engine/alphize'
+
+module SwfConverter
+  class Engine
+    attr_accessor :parent
+    attr_reader :options
+
+    def initialize
+      @options = {}
+    end
+
+    def options=(new_options)
+      validate_options!(new_options) if respond_to?(:validate_options!)
+      @options = new_options
+    end
+
+    def convert!(swf_parent)
+      raise NotImplementedError, "SwfConverter::Engine#convert! has no defined behavior. Subclass it and define your own."
+    end
+  end
+end
+

data/lib/swf_converter/engine/alphize.rb

@@ -0,0 +1,132 @@
+require 'fileutils'
+require 'shellwords'
+require 'tempfile'
+
+require 'swf_converter/engine'
+require 'swf_converter/engine/alphize/blender'
+require 'swf_converter/engine/alphize/runner'
+
+module SwfConverter
+  class Engine
+    class Alphize < Engine
+      SWF_PATHS = {}.tap do |paths|
+        [:black, :white].each do |type|
+          paths[type] = File.expand_path("../alphize/swfs/#{type}.swf", __FILE__)
+        end
+      end
+
+      include Runner
+
+      def initialize
+        @output_images = {}
+      end
+
+      def convert!(swf_parent)
+        images = {
+          :black => Tempfile.open('swf_converter_alphize_black.png'),
+          :white => Tempfile.open('swf_converter_alphize_white.png')
+        }
+        begin
+          write_opaque_images(swf_parent, images)
+          blend(swf_parent, images)
+          if swf_parent.respond_to?(:after_swf_conversion)
+            swf_parent.after_swf_conversion(@output_images)
+          end
+        ensure
+          images[:black].close!
+          images[:white].close!
+        end
+      end
+
+      protected
+
+      def write_opaque_images(swf_parent, images)
+        raw = Tempfile.open 'swf_converter_alphize_raw'
+        raw_path = e(raw.path)
+        size = @options[:size]
+        unless size
+          raise ":size option must be set to the original SWF dimensions"
+        end
+        # Each RGBA pixel takes a byte, so the filesize of one frame is the
+        # number of pixels (width * height) times the number of channels (4)
+        frame_filesize = size[0] * size[1] * 4
+        begin
+          images.each do |type, image|
+            wrapper_swf = e(SWF_PATHS[type])
+            params = e("FlashVars=includeSWF=file://#{swf_parent.local_swf_path}")
+            image_path = e(image.path)
+            run "create raw SWF dump on #{type}",
+              "dump-gnash #{wrapper_swf} -P #{params} " +
+              "-D #{raw_path} --max-advances 1 -j #{size[0]} -k #{size[1]} > /dev/null"
+            run "create opaque image from raw on #{type}",
+              "tail -c #{frame_filesize} #{raw_path} | convert -size #{size[0]}x#{size[1]} -depth 8 rgba:- " +
+              "-separate -swap 0,2 -combine png:#{image_path}"
+          end
+        ensure
+          raw.close!
+        end
+      end
+
+      def blend(swf_parent, images)
+        begin
+          blender = Blender.new(images)
+          if @options[:output_sizes]
+            blend_and_resize(swf_parent, blender)
+          else
+            output_path = prepare_path(swf_parent.swf_image_path)
+            blender.blend! output_path
+            @output_images[@options[:size]] = output_path
+          end
+        rescue Exception => e
+          raise ConversionError, "Could not blend opaque images: #{e.class}: #{e.message}", e.backtrace
+        end
+      end
+
+      def blend_and_resize(swf_parent, blender)
+        original_image = Tempfile.new('swf_converter_alphize_original.png')
+        original_path = original_image.path
+        begin
+          blender.blend! original_path
+          @options[:output_sizes].each do |size|
+            resize(swf_parent, size, original_path)
+          end
+        ensure
+          original_image.close!
+        end
+      end
+
+      def prepare_path(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        path
+      end
+
+      def resize(swf_parent, size, original_path)
+        output_path = prepare_path(swf_parent.swf_image_path(size))
+        run "resize #{original_path} to #{size} at #{output_path}",
+          "convert #{original_path} -resize #{size[0]}x#{size[1]} #{output_path}"
+        @output_images[size] = output_path
+      end
+
+      def validate_options!(options)
+        if options[:size]
+          validate_size(options[:size], ":size option")
+        end
+
+        if options[:output_sizes]
+          options[:output_sizes].each_with_index do |size, n|
+            validate_size(size, "Element #{n} of :output_sizes option")
+          end
+        end
+      end
+
+      def validate_size(size, description)
+        unless size.is_a?(Array) && size.size == 2
+          raise ArgumentError, "#{description} must be a 2-dimensional array, but was #{size}"
+        end
+      end
+
+      class ConversionError < StandardError;end
+    end
+  end
+end
+

data/lib/swf_converter/engine/alphize/blender.rb

@@ -0,0 +1,80 @@
+require 'swf_converter/engine/alphize/runner'
+
+module SwfConverter
+  class Engine
+    class Alphize < Engine
+      TEMP_NAMES = [:negative, :alpha, :division]
+
+      class Blender
+        include Runner
+
+        def initialize(images)
+          @originals = images
+        end
+
+        def blend!(output_path)
+          # The strategy here is based on the following principle:
+          # original_image.alpha == (CHANNEL_MAX - image_on_white.red) + image_on_black.red
+          # (Applies to blue and green, too. Derived from the formulas applied
+          # by the original composition; not too hard to work out.)
+          # So, we will first get a grayscale version of an alpha mask by
+          # negating the image-on-white (create_negative!), then add it to the
+          # image-on-black to get the grayscale alpha mask (create_alpha!).
+          # The alpha mask image has white where the original image is opaque,
+          # and black where it is fully transparent, and gray where it is
+          # partially transparent. Once we have that image, since the RGB
+          # values in image-on-black were found by multiplying by the alpha
+          # value, we divide image-on-black by the grayscale alpha mask to get
+          # an opaque version of the image with the correct colors
+          # (create_division!), then apply that grayscale image as an alpha
+          # mask to save the final image (create_final!).
+          with_temps do |temps|
+            create_negative!(temps)
+            create_alpha!(temps)
+            create_division!(temps)
+            create_final!(output_path, temps)
+          end
+        end
+
+        protected
+
+        def create_alpha!(temps)
+          run "create alpha mask for blending",
+            "convert #{@originals[:black].path} #{temps[:negative].path} " +
+            "-alpha Off -compose Plus -composite #{temps[:alpha].path}"
+        end
+
+        def create_division!(temps)
+          run "create division image for blending",
+            "composite #{@originals[:black].path} #{temps[:alpha].path} " +
+            "-alpha Off -channel RGB -compose Divide #{temps[:division].path}"
+        end
+
+        def create_final!(output_path, temps)
+          run "create final image for blending",
+            "convert #{temps[:division].path} #{temps[:alpha].path} " +
+            "-compose CopyOpacity -composite #{output_path}"
+        end
+
+        def create_negative!(temps)
+          run "create negative image for blending",
+            "convert #{@originals[:white].path} " +
+            "-alpha Off -channel RGB -negate #{temps[:negative].path}"
+        end
+
+        def with_temps
+          temps = (TEMP_NAMES.inject({}) do |hash, name|
+            hash[name] = Tempfile.open ["swf_converter_alphize_blender_#{name}", '.png']
+            hash
+          end)
+          begin
+            yield(temps)
+          ensure
+            temps.each { |name, temp| temp.close! }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/swf_converter/engine/alphize/runner.rb

@@ -0,0 +1,18 @@
+module SwfConverter
+  class Engine
+    class Alphize < Engine
+      module Runner
+        def e(*args)
+          Shellwords.escape(*args)
+        end
+
+        def run(description, command)
+          unless system(command)
+            raise ConversionError, "Failed to #{description}: #{command.inspect}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/swf_converter/engine/alphize/swfs/src/Preview.as

@@ -0,0 +1,20 @@
+class Preview extends MovieClip {
+  var mytf:TextField;
+ 
+	function Preview(scope:MovieClip) {
+	  var mc:MovieClip = scope.createEmptyMovieClip("mc", scope.getNextHighestDepth());
+    var my_listener:Object = new Object();
+
+    my_listener.onLoadComplete = function(target_mc:MovieClip) {
+      mc.opaqueBackground = 0x0000FF;
+    }
+
+    var my_loader:MovieClipLoader = new MovieClipLoader();
+    my_loader.addListener(my_listener);
+    my_loader.loadClip(scope.includeSWF, mc);
+	}
+ 
+	function onLoad() {
+	  var preview:Preview = new Preview(_root);
+	}
+}

data/lib/swf_converter/engine/alphize/swfs/src/black.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<movie width="600" height="600" framerate="12">
+  <background color="#000000"/>
+  <clip import="classes.swf" />
+ 
+  <frame>
+    <library>
+      <clip id="app" class="Preview" />
+    </library>
+ 
+    <place id="app" name="myApp" depth="0" height="500" width="500" x="0" y="0" />
+  </frame>
+</movie>

data/lib/swf_converter/engine/alphize/swfs/src/build.sh

@@ -0,0 +1,3 @@
+mtasc -swf classes.swf -header 1:1:24 Preview.as
+swfmill simple black.xml ../black.swf
+swfmill simple white.xml ../white.swf

data/lib/swf_converter/engine/alphize/swfs/src/white.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<movie width="600" height="600" framerate="12">
+  <background color="#FFFFFF"/>
+  <clip import="classes.swf" />
+ 
+  <frame>
+    <library>
+      <clip id="app" class="Preview" />
+    </library>
+ 
+    <place id="app" name="myApp" depth="0" height="500" width="500" x="0" y="0" />
+  </frame>
+</movie>

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+$:.unshift File.expand_path('..', __FILE__)
+
+require 'swf_converter/engine'
+
+class Swf
+  include SwfConverter
+end
+
+class OtherSwf
+  include SwfConverter
+end
+
+class VanillaSwf
+  include SwfConverter
+end
+
+class DummyEngine < SwfConverter::Engine; end
+class OtherDummyEngine < SwfConverter::Engine; end
+
+class ValidatingEngine < SwfConverter::Engine
+  def validate_options!(new_options)
+    unless new_options[:sizes]
+      raise SwfConverter::InvalidOptions, "CustomEngine requires sizes option"
+    end
+  end
+end
+
+class SupposedlyConvertingEngine < SwfConverter::Engine
+  def convert!(swf_parent)
+    # supposedly convert
+  end
+end
+
+RSpec::Matchers.define :match_image do |file2|
+  require 'RMagick'
+
+  match do |file1|
+    signatures = [file1, file2].map do |file_or_path|
+      is_file = file_or_path.is_a? File
+      if is_file
+        file = file_or_path
+      else
+        file = File.open(file_or_path, 'r')
+      end
+
+      image = Magick::Image::from_blob(file.read)[0]
+      file.close unless is_file
+      signature = image.signature
+      image.destroy!
+      signature
+    end
+
+    signatures[0] == signatures[1]
+  end
+end
+
+def example_path(subpath)
+  File.expand_path(File.join('..', '..', 'examples', subpath), __FILE__)
+end
+

data/spec/swf_converter/engine/alphize_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'swf_converter/engine/alphize'
+
+require 'tempfile'
+require 'tmpdir'
+
+describe SwfConverter::Engine::Alphize do
+  before(:each) do
+    @engine = SwfConverter::Engine::Alphize.new
+  end
+
+  describe "size option" do
+    it "should be settable" do
+      @engine.options = {:size => [300, 500]}
+      @engine.options[:size].should == [300, 500]
+    end
+
+    it "should require a 2-dimensional array" do
+      lambda { @engine.options = {:size => [300, 300]} }.should_not raise_error
+      lambda { @engine.options = {:size => [7, 8]} }.should_not raise_error
+      lambda { @engine.options = {:size => 300} }.should raise_error
+      lambda { @engine.options = {:size => [300]} }.should raise_error
+      lambda { @engine.options = {:size => [300, 300, 300]} }.should raise_error
+      lambda { @engine.options = {:size => [300, 300, 300, 300]} }.should raise_error
+    end
+  end
+
+  describe "output_sizes option" do
+    it "should be settable" do
+      @engine.options = {:output_sizes => [[300, 300]]}
+      @engine.options[:output_sizes].should == [[300, 300]]
+    end
+
+    it "should require all elements to be 2-dimensional arrays" do
+      lambda { @engine.options = {:output_sizes => [[300, 300]]} }.should_not raise_error
+      lambda { @engine.options = {:output_sizes => [[300, 300], [7, 8]]} }.should_not raise_error
+      lambda { @engine.options = {:output_sizes => [[300, 300], [7, 8], [1026, 1993]]} }.should_not raise_error
+      lambda { @engine.options = {:output_sizes => 300} }.should raise_error
+      lambda { @engine.options = {:output_sizes => [300]} }.should raise_error
+      lambda { @engine.options = {:output_sizes => [[300]]} }.should raise_error
+      lambda { @engine.options = {:output_sizes => [300, 300]} }.should raise_error
+      lambda { @engine.options = {:output_sizes => [[150, 150], [300]]} }.should raise_error
+      lambda { @engine.options = {:output_sizes => [[300, 300], [150, 150], [10, 26, 1993]]} }.should raise_error
+    end
+  end
+
+  describe "with a size of 600x600 set" do
+    before(:each) do
+      @engine.options = {:size => [600, 600]}
+    end
+
+    it "should convert the balloon to a single 600x600 image" do
+      output_file = Tempfile.new 'balloon.png'
+      begin
+        parent = mock('balloon', :local_swf_path => example_path('balloon.swf'),
+          :swf_image_path => output_file.path)
+        @engine.convert! parent
+        output_file.should match_image(example_path('balloon.png'))
+      ensure
+        output_file.close!
+      end
+    end
+
+    it "should create the destination directory for the balloon if does not exist" do
+      dir = File.join(Dir.tmpdir, 'swf_converter_alphize_spec_tmpdir')
+      Dir.delete(dir) if Dir.exist?(dir)
+      output_file_path = File.join(dir, 'balloon.png')
+      output_file = nil
+      begin
+        parent = mock('balloon', :local_swf_path => example_path('balloon.swf'),
+          :swf_image_path => output_file_path)
+        @engine.convert! parent
+        output_file = File.open(output_file_path)
+        output_file.should match_image(example_path('balloon.png'))
+      ensure
+        File.delete(output_file_path) if File.exist?(output_file_path)
+        Dir.delete(dir) if Dir.exist?(dir)
+      end
+    end
+
+    it "should convert the rainy day to a single 600x600 image" do
+      output_file = Tempfile.new 'rainy_day.png'
+      begin
+        parent = mock('rainy_day', :local_swf_path => example_path('rainy_day.swf'),
+          :swf_image_path => output_file.path)
+        @engine.convert! parent
+        output_file.should match_image(example_path('rainy_day.png'))
+      ensure
+        output_file.close!
+      end
+    end
+
+    describe "and 80x80 and 150x150 output sizes set" do
+      before(:each) do
+        @engine.options[:output_sizes] = [
+          [80, 80],
+          [150, 150]
+        ]
+
+        @thumbnails = {
+          80 => Tempfile.new('balloon80.png'),
+          150 => Tempfile.new('balloon150.png')
+        }
+
+        @parent = mock('balloon_thumbnails', :local_swf_path => example_path('balloon.swf'))
+        @parent.stub!(:swf_image_path).with([80, 80]).and_return(@thumbnails[80].path)
+        @parent.stub!(:swf_image_path).with([150, 150]).and_return(@thumbnails[150].path)
+      end
+
+      it "should convert the balloon to 80x80 and 150x150 thumbnails" do
+        @engine.convert! @parent
+        @thumbnails[80].should match_image(example_path('balloon/80x80.png'))
+        @thumbnails[150].should match_image(example_path('balloon/150x150.png'))
+      end
+
+      it "should run an after hook if set" do
+        @parent.should_receive(:after_swf_conversion).with({
+          [80, 80] => @thumbnails[80].path,
+          [150, 150] => @thumbnails[150].path
+        })
+        @engine.convert! @parent
+      end
+    end
+  end
+end
+

data/spec/swf_converter/engine_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'swf_converter/engine'
+
+describe SwfConverter::Engine do
+  describe "#options" do
+    it "should return the options set" do
+      engine = SwfConverter::Engine.new
+      engine.options = {:foo => :bar}
+      engine.options.should == {:foo => :bar}
+    end
+    
+    it "should allow a subclass to validate options on set" do
+      lambda {
+        engine = ValidatingEngine.new
+        engine.options = {:foo => :bar}
+      }.should raise_error(SwfConverter::InvalidOptions)
+      
+      lambda {
+        engine = ValidatingEngine.new
+        engine.options = {:foo => :bar, :sizes => [150, 300]}
+      }.should_not raise_error
+    end
+  end
+  
+  describe "#convert!" do
+    it "should raise an error if not implemented by subclass" do
+      parent = mock('engine_conversion_parent')
+      
+      lambda {
+        engine = SwfConverter::Engine.new
+        engine.convert!(parent)
+      }.should raise_error(NotImplementedError)
+      
+      lambda {
+        engine = SupposedlyConvertingEngine.new
+        engine.convert!(parent)
+      }.should_not raise_error
+    end
+  end
+end

data/spec/swf_converter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'swf_converter'
+
+describe SwfConverter do
+  it "should have alphize set by default" do
+    VanillaSwf.swf_conversion_engine.should be_a SwfConverter::Engine::Alphize
+  end
+
+  it "should allow class to set its own engine" do
+    Swf.converts_swfs :with => DummyEngine
+    OtherSwf.converts_swfs :with => OtherDummyEngine
+
+    Swf.swf_conversion_engine.should be_a DummyEngine
+    OtherSwf.swf_conversion_engine.should be_a OtherDummyEngine
+  end
+
+  it "should allow class to set options" do
+    Swf.converts_swfs :with => DummyEngine, :foo => :bar
+    Swf.swf_conversion_engine.options.should == {:foo => :bar}
+  end
+
+  describe "#convert_swf!" do
+    it "should call engine#convert" do
+      engine_class = mock('swf_engine_requiring_conversion_class')
+      engine = mock('swf_engine_requiring_conversion')
+      engine.stub!(:options=)
+      engine_class.stub!(:new).and_return(engine)
+      Swf.converts_swfs :with => engine_class
+      swf = Swf.new
+      engine.should_receive(:convert!).with(swf)
+      swf.convert_swf!
+    end
+  end
+end
+

data/swf_converter.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = 'swf_converter'
+  s.version = '0.0.3'
+  s.platform = Gem::Platform::RUBY
+  s.author = 'Matchu'
+  s.email = ['matchu1993@gmail.com']
+  s.summary = 'Converts SWFs to PNGs'
+  s.description = "Include SwfConverter on a class to get #convert_swf!, which writes PNGs from that object's SWF file. Work in progress."
+  s.require_path = 'lib'
+  s.files = `git ls-files`.split("\n")
+end
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: swf_converter
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Matchu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-22 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "Include SwfConverter on a class to get #convert_swf!, which writes PNGs from that object's SWF file. Work in progress."
+email: 
+- matchu1993@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- autotest/discover.rb
+- check_memory.rb
+- examples/balloon.png
+- examples/balloon.swf
+- examples/balloon/150x150.png
+- examples/balloon/80x80.png
+- examples/rainy_day.png
+- examples/rainy_day.swf
+- lib/swf_converter.rb
+- lib/swf_converter/engine.rb
+- lib/swf_converter/engine/alphize.rb
+- lib/swf_converter/engine/alphize/blender.rb
+- lib/swf_converter/engine/alphize/runner.rb
+- lib/swf_converter/engine/alphize/swfs/black.swf
+- lib/swf_converter/engine/alphize/swfs/src/Preview.as
+- lib/swf_converter/engine/alphize/swfs/src/black.xml
+- lib/swf_converter/engine/alphize/swfs/src/build.sh
+- lib/swf_converter/engine/alphize/swfs/src/classes.swf
+- lib/swf_converter/engine/alphize/swfs/src/white.xml
+- lib/swf_converter/engine/alphize/swfs/white.swf
+- spec/spec_helper.rb
+- spec/swf_converter/engine/alphize_spec.rb
+- spec/swf_converter/engine_spec.rb
+- spec/swf_converter_spec.rb
+- swf_converter.gemspec
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Converts SWFs to PNGs
+test_files: []
+