root/lang/ruby/partty/trunk/captty.rb @ 8952

require 'zlib'

module Captty

        module FRAME
                OUTPUT = 0
                WINDOW_SIZE = 1
                HEADER_SIZE = 8 + 1 + 2
        end

        module BLOCK
                UNCOMPRESSED_FRAMES = 0
                COMPRESSED_FRAMES = 1
                HEADER_SIZE = 8 + 1 + 2
        end

        BLOCK_TIME_SPAN = 30   # seconds
        MAX_BLOCK_SIZE = 1 << 19



        class Recorder
                def initialize(output_stream)
                        @out = output_stream
                        @block = ""
                        @ftime = Time.now
                        @btime = Time.now
                end

                def write(buf)
                        append_frame(
                                ftdiff_forward,
                                buf,
                                FRAME::OUTPUT
                        )
                end

                def set_window_size(row, col)
                        buf = [row, col].pack("vv")
                        append_frame(
                                ftdiff_forward,
                                buf,
                                FRAME::WINDOW_SIZE
                        )
                end

                def flush
                        reserve(MAX_BLOCK_SIZE+1)
                end


        private
                def append_frame(ftdiff, buf, flag)
                        reserve(FRAME::HEADER_SIZE + buf.length)
                        @block << [ftdiff, flag, buf.length].pack("VCv")
                        @block << buf
                        buf
                end

                # ftdiff in microseconds
                def ftdiff_forward
                        n = Time.now
                        ftdiff = ((n - @ftime).to_f * 1000 * 1000).to_i
                        @ftime = n
                        ftdiff
                end

                def reserve(length)
                        n = Time.now
                        if (n - @btime).to_i > BLOCK_TIME_SPAN ||
                                @block.length + length > MAX_BLOCK_SIZE
                                write_block( (n - @btime).to_i )
                                @btime = n
                                @block.slice!(0..-1)  # == @block.clear (1.9 feature)
                        end
                end

                def write_block(btdiff)
                        failed = false
                        begin
                                cblock = Zlib::Deflate.deflate(@block)
                        rescue
                                failed = true
                        end
                        failed = true   # FIXME  compression doesn't work?
                        if !failed && cblock.length < @block.length
                                write_block_data(BLOCK::COMPRESSED_FRAMES, btdiff, cblock)
                        else
                                write_block_data(BLOCK::UNCOMPRESSED_FRAMES, btdiff, @block)
                        end
                end

                def write_block_data(flag, btdiff, data)
                        @out.write [btdiff, flag, data.length].pack("vCV")
                        @out.write @block
                end
        end

end