furnace-swf 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swf

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in furnace-swf.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/furnace-swf

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "trollop"
+require "furnace-swf"
+
+include Furnace
+
+SUBCOMMANDS = %w(abclist abcextract abcreplace)
+
+opts = Trollop::options do
+  version "furnace-swf #{SWF::VERSION}"
+  banner <<-EOS
+  furnace-swf is a processing tool which operates on Flash SWF files.
+
+  Possible subcommands: #{SUBCOMMANDS.join ' '}
+  Try #{__FILE__} subcommand --help.
+
+  Usage: #{__FILE__} [options] <subcommand>
+EOS
+
+  opt :input,    "SWF input file",   :type => :io
+  opt :trace,    "Trace reading",    :default => false
+
+  stop_on SUBCOMMANDS
+end
+
+subcommand = ARGV.shift
+subopts = case subcommand
+when 'abclist'
+  Trollop::options do
+  end
+
+when 'abcextract'
+  Trollop::options do
+    opt :name,    "ABC tag name",     :type => :string, :required => true
+    opt :output,  "ABC output file",  :type => :string, :required => true
+  end
+
+when 'abcreplace'
+  Trollop::options do
+    opt :name,    "ABC tag name",             :type => :string, :required => true
+    opt :input,   "ABC input file",           :type => :io,     :required => true
+    opt :output,  "Combined SWF output file", :type => :string, :required => true
+  end
+end
+
+Trollop::die "Option --input is required" unless opts[:input]
+
+swf = nil
+File.open(opts[:input]) do |file|
+  swf = SWF::File.new
+
+  if opts[:trace]
+    BinData::trace_reading do
+      swf.read(file)
+    end
+  else
+    swf.read(file)
+  end
+end
+
+case subcommand
+when 'abclist'
+  puts "ABC tags:"
+
+  swf.stream.tags(SWF::DoABCTag).each do |tag|
+    puts "  #{tag.name.inspect}: #{tag.bytecode.length} byte(s)"
+  end
+
+when 'abcextract'
+  if tag = swf.stream.tags(SWF::DoABCTag).find { |tag| tag.name == subopts[:name] }
+    File.open(subopts[:output], 'w') do |f|
+      f.write tag.bytecode
+    end
+  else
+    puts "Tag #{subopts[:name].inspect} was not found"
+    exit 1
+  end
+
+when 'abcreplace'
+  if tag = swf.stream.tags(SWF::DoABCTag).find { |tag| tag.name == subopts[:name] }
+    tag.bytecode = subopts[:input].read
+
+    File.open(subopts[:output], 'w') do |f|
+      swf.write f
+    end
+  else
+    puts "Tag #{subopts[:name].inspect} was not found"
+    exit 1
+  end
+end

data/furnace-swf.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "furnace-swf"
+  s.version     = "0.0.1"
+  s.authors     = ["Peter Zotov", "Sergey Gridassov"]
+  s.email       = ["whitequark@whitequark.org", "grindars@gmail.com"]
+  s.homepage    = "http://github.com/whitequark/furnace-swf"
+  s.summary     = %q{Flash SWF file reader and writer}
+  s.description = %q{furnace-swf allows one to load, modify and write back } <<
+                  %q{Flash SWF files. It can be used with furnace-avm2 in } <<
+                  %q{order to achieve impressive results.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+s.add_runtime_dependency "bindata"
+  s.add_runtime_dependency "trollop"
+end

data/lib/furnace-swf.rb

@@ -0,0 +1,8 @@
+module Furnace
+  module SWF
+  end
+end
+
+require "furnace-swf/version"
+
+require "furnace-swf/swf"

data/lib/furnace-swf/swf.rb

@@ -0,0 +1,17 @@
+require "bindata"
+
+require_relative "swf/sbit"
+require_relative "swf/ubit"
+
+require_relative "swf/rect"
+
+require_relative "swf/tag_wrapper"
+require_relative "swf/tag"
+
+Dir[File.join(File.dirname(__FILE__), 'swf', 'tags', '*.rb')].each do |tag|
+  require tag
+end
+
+require_relative "swf/header"
+require_relative "swf/stream"
+require_relative "swf/file"

data/lib/furnace-swf/swf/file.rb

@@ -0,0 +1,40 @@
+require 'zlib'
+
+module Furnace::SWF
+  class File < BinData::Record
+    header :header
+    stream :stream
+
+    def do_read(io)
+      instantiate_all_objs
+
+      header = find_obj_for_name(:header)
+      stream = find_obj_for_name(:stream)
+
+      header.do_read(io)
+
+      case header.signature
+      when 'FWS'
+        stream.do_read io
+      when 'CWS'
+        uncompressed = Zlib.inflate(io.read_all_bytes)
+        stream.do_read BinData::IO.new(StringIO.new(uncompressed))
+      else
+        raise ArgumentError, "invalid signature"
+      end
+    end
+
+    def do_write(io)
+      instantiate_all_objs
+
+      header = find_obj_for_name(:header)
+      stream = find_obj_for_name(:stream)
+
+      header.signature   = 'FWS'
+      header.file_length = header.num_bytes + stream.real_num_bytes
+
+      header.do_write(io)
+      stream.do_write(io)
+    end
+  end
+end

data/lib/furnace-swf/swf/header.rb

@@ -0,0 +1,9 @@
+module Furnace::SWF
+  class Header < BinData::Record
+    endian :little
+
+    string :signature,   :length => 3
+    uint8  :version
+    uint32 :file_length
+  end
+end

data/lib/furnace-swf/swf/rect.rb

@@ -0,0 +1,9 @@
+module Furnace::SWF
+  class Rect < BinData::Record
+    bit5 :num_bits
+    sbit :x_min,    :length => :num_bits
+    sbit :x_max,    :length => :num_bits
+    sbit :y_min,    :length => :num_bits
+    sbit :y_max,    :length => :num_bits
+  end
+end

data/lib/furnace-swf/swf/sbit.rb

@@ -0,0 +1,21 @@
+module Furnace::SWF
+  class Sbit < BinData::BasePrimitive
+    mandatory_parameter :length
+
+    def do_write(io)
+      io.writebits(_value, eval_parameter(:length), :big)
+    end
+
+    def do_num_bytes
+      eval_parameter(:length) / 8.0
+    end
+
+    def read_and_return_value(io)
+      io.readbits(eval_parameter(:length), :big)
+    end
+
+    def sensible_default
+      0
+    end
+  end
+end

data/lib/furnace-swf/swf/stream.rb

@@ -0,0 +1,25 @@
+module Furnace::SWF
+  class Stream < BinData::Record
+    endian :little
+
+    rect   :frame_size
+    uint8  :frame_rate_lo
+    uint8  :frame_rate_hi
+    uint16 :frame_count
+
+    array  :tag_wrappers, :type => :tag_wrapper, :read_until => :eof
+
+    def frame_rate
+      BigDecimal.new(frame_rate_hi) +
+          BigDecimal.new(frame_rate_lo) / 100
+    end
+
+    def tags(type)
+     tag_wrappers.select { |tw| tw.content.is_a? type }.map(&:content)
+    end
+
+    def real_num_bytes
+      num_bytes + tag_wrappers.map(&:content_size).reduce(0, :+)
+    end
+  end
+end

data/lib/furnace-swf/swf/tag.rb

@@ -0,0 +1,34 @@
+module Furnace::SWF
+  class Tag < BinData::Record
+    mandatory_parameter :stream
+
+    endian :little
+
+    REGISTRY = {}
+
+    def self.exists_for?(type)
+      REGISTRY.has_key? type
+    end
+
+    def self.instantiate(type, parent, stream)
+      REGISTRY[type].new({ stream: stream }, parent)
+    end
+
+    # DSL
+
+    class << self
+      def type(id)
+        Tag::REGISTRY[id] = self
+
+        define_method(:type) do
+          id
+        end
+      end
+    end
+
+    def initialize_instance
+      super
+      @stream = @params[:stream]
+    end
+  end
+end

data/lib/furnace-swf/swf/tag_wrapper.rb

@@ -0,0 +1,85 @@
+module Furnace::SWF
+  class TagWrapper < BinData::Record
+    endian :little
+
+    uint16 :type_and_length
+    int32  :long_length,     :onlyif => lambda { short_length == 0x3f }
+
+    attr_accessor :content
+
+    # Accessors for braindead format.
+
+    def type
+      type_and_length >> 6
+    end
+
+    def type=(value)
+      self.type_and_length = (type_and_length & 0x3f) | (value << 6)
+    end
+
+    def short_length
+      type_and_length & 0x3f
+    end
+
+    def short_length=(value)
+      self.type_and_length = (type_and_length & 0xfffc) | (value & 0x3f)
+    end
+
+    def real_length
+      short_length == 0x3f ? long_length : short_length
+    end
+
+    def real_length=(value)
+      if value > 0x3f
+        self.short_length = 0x3f
+        self.long_length  = value
+      else
+        self.short_length = value
+        self.long_length  = 0
+      end
+    end
+
+    # Nested reads/writes.
+
+    def do_read(io)
+      super
+
+      orig_offset = io.offset
+
+      if Tag.exists_for?(type)
+        @content  = Tag.instantiate(type, self, parent)
+        @content.do_read io
+
+        if io.offset - orig_offset != real_length
+          raise "Invalid tag #{@content}"
+        end
+      else
+        @content  = io.readbytes(real_length)
+      end
+    end
+
+    def do_write(io)
+      super
+
+      if Tag.exists_for?(type)
+        @content.do_write io
+      else
+        io.writebytes @content
+      end
+    end
+
+    def do_num_bytes
+      self.real_length = content_size
+
+      super
+    end
+
+    def content_size
+      if @content.is_a? Tag
+        @content.num_bytes
+      else
+        @content.length
+      end
+    end
+  end
+end

data/lib/furnace-swf/swf/tags/define_binary_data_tag.rb

@@ -0,0 +1,9 @@
+module Furnace::SWF
+  class DefineBinaryTag < Tag
+    type 87
+
+    uint16  :tag
+    uint32  :reserved
+    string  :data,    :read_length => lambda { parent.real_length - 6 }
+  end
+end

data/lib/furnace-swf/swf/tags/do_abc_tag.rb

@@ -0,0 +1,9 @@
+module Furnace::SWF
+  class DoABCTag < Tag
+    type 82
+
+    uint32  :flags
+    stringz :name
+    string  :bytecode, :read_length => lambda { parent.real_length - 4 - name.length - 1 }
+  end
+end

data/lib/furnace-swf/swf/tags/symbol_class_tag.rb

@@ -0,0 +1,11 @@
+module Furnace::SWF
+  class SymbolClassTag < Tag
+    type 76
+
+    uint16  :num_symbols, :value => lambda { symbols.count }
+    array   :symbols,     :initial_length => :num_symbols do
+      uint16  :tag
+      stringz :name
+    end
+  end
+end

data/lib/furnace-swf/swf/ubit.rb

@@ -0,0 +1,21 @@
+module Furnace::SWF
+  class Ubit < BinData::BasePrimitive
+    mandatory_parameter :length
+
+    def do_write(io)
+      io.writebits(_value, eval_parameter(:length), :little)
+    end
+
+    def do_num_bytes
+      eval_parameter(:length) / 8.0
+    end
+
+    def read_and_return_value(io)
+      io.readbits(eval_parameter(:length), :big)
+    end
+
+    def sensible_default
+      0
+    end
+  end
+end

data/lib/furnace-swf/version.rb

@@ -0,0 +1,3 @@
+module Furnace::SWF
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: furnace-swf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Peter Zotov
+- Sergey Gridassov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &71683110 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *71683110
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &71682470 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *71682470
+description: furnace-swf allows one to load, modify and write back Flash SWF files.
+  It can be used with furnace-avm2 in order to achieve impressive results.
+email:
+- whitequark@whitequark.org
+- grindars@gmail.com
+executables:
+- furnace-swf
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/furnace-swf
+- furnace-swf.gemspec
+- lib/furnace-swf.rb
+- lib/furnace-swf/swf.rb
+- lib/furnace-swf/swf/file.rb
+- lib/furnace-swf/swf/header.rb
+- lib/furnace-swf/swf/rect.rb
+- lib/furnace-swf/swf/sbit.rb
+- lib/furnace-swf/swf/stream.rb
+- lib/furnace-swf/swf/tag.rb
+- lib/furnace-swf/swf/tag_wrapper.rb
+- lib/furnace-swf/swf/tags/define_binary_data_tag.rb
+- lib/furnace-swf/swf/tags/do_abc_tag.rb
+- lib/furnace-swf/swf/tags/symbol_class_tag.rb
+- lib/furnace-swf/swf/ubit.rb
+- lib/furnace-swf/version.rb
+homepage: http://github.com/whitequark/furnace-swf
+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.8.10
+signing_key: 
+specification_version: 3
+summary: Flash SWF file reader and writer
+test_files: []
+has_rdoc: