root/lang/ruby/asc3to2/swf.rb @ 7736

# swf.rb
#  based on AsConverter.rb by KLab, Inc.

require 'zlib'
module SWF

SWFTAG = {
        9  => "SETBACKGROUNDCOLOR",
        1  => "SHOWFRAME",
        12 => "DOACTION",
        39 => "DEFINESPRITE",
        56 => "EXPORTASSETS",
        59 => "INITACTION",
        82 => "DOABC",
        -1 => "unknown"
}

ACTIONS = {

        0x0b => "SUBTRACT"    ,
        0x0c => "MULTIPLY"    ,
        0x0d => "DIVIDE"      ,
        0x17 => "POP"         ,
        0x12 => "LOGICALNOT"  ,
#       0x18 => "INT"         ,
        0x1c => "GETVARIABLE" ,
        0x3d => "CALLFUNCTION",
        0x3e => "RETURN"      ,
        0x3f => "MODULO"      ,
        0x40 => "NEW"         ,
        0x41 => "VAR"         ,
        0x42 => "INITARRAY"   ,
        0x47 => "NEWADD"      ,
        0x48 => "NEWLESSTHAN" ,
        0x49 => "NEWEQUALS"   ,
        0x4e => "GETMEMBER"   ,
        0x4f => "SETMEMBER"   ,
        0x50 => "INCREMENT"   ,
        0x52 => "CALLMETHOD"  ,

        0x87 => "SETREGISTER" ,
        0x88 => "CONSTANTPOOL",
        0x8e => "DEFINEFUNCTION2",
        0x96 => "PUSHDATA"    ,
        0x99 => "BRANCHALWAYS",
        0x9d => "BRANCHIFTRUE"
}

class SWF
        def load(filename)
                bs  = nil

                File.open(filename) {|infile|
                        infile.binmode
                        src = infile.read
                        bs = make_bits(src)
                }

                # 最初の64ビットを無視
                bs.read(64)

                # RECT構造体
                rl = bs.read_as_int(5) # 構造体各要素長さ
                bs.read(5 + (4*rl))    # RECT構造体を無視

                bs.align_byte

                # ヘッダの残り32ビットを無視
                bs.read(32)
                
                read_tags(bs)
        end

        def read_tags(bs)
                begin
                        tag_and_length = bs.read_short
                        tag_id  = tag_and_length >> 6
                        tag_len = tag_and_length & 0x3f

                        break if tag_id == 0 # END tag

                        # longタグ
                        if (0x3f == tag_len)
                                tag_len =       bs.read_as_int(8)         |
                                                        (bs.read_as_int(8) << 8 ) |
                                                        (bs.read_as_int(8) << 16) |
                                                        (bs.read_as_int(8) << 24)
                        end

                        handle_tag(bs, tag_id, tag_len)
                end while bs.empty?
        end

        def make_bits(src)
                # ヘッダ部
                ## CWS形式だったらswfを読み込み直す
                if src[0] == 67 # 'C'
                        bits = src[0,8].unpack("B*").to_s
                        bits << Zlib::Inflate.inflate(src[8, src.length-8]).unpack("B*").to_s

                        return BitStream.new(bits)
                else
                        return BitStream.new(src.unpack("B*").to_s)
                end

                raise "must not be reached"
        end

        def handle_tag(bs, tag_id, tag_len)
                tagname = "unknown"
                tagname = SWFTAG[tag_id] if SWFTAG.has_key?(tag_id)

                handler_name = "tag#{tagname}"

                # puts "tag=#{tagname} len=#{tag_len}"

                # タグに対応するメソッドを探す
                if respond_to?(handler_name)
                        __send__(handler_name, bs, tag_len)
                else
                        # 未知のタグを読み飛ばす
                        bs.read(8*tag_len)
                end
        end
end

class BitStream
        def initialize(bits)
                @bits = bits
                @pos = 0
                @length = bits.length
        end

        def empty?
                return @pos < @length
        end
        
        attr_reader :length

        def read(count)
                ret = @bits[@pos, count]
                @pos += count

                return ret
        end

        def read_byte(count = 1)
                read(count*8)
        end
        
        def read_as_stream(count)
                BitStream.new(read(count))
        end

        def read_as_int(count)
                ret = @bits[@pos, count]
                @pos += count

                return ret.to_i(2)
        end

        def read_short
                read_as_int(8) | (read_as_int(8) << 8)
        end

        def align_byte
                @pos += 8 - (@pos%8)
        end
end


end # of module SWF