ONI.rb

require 'base64'
require 'chunky_png'


class ChunkyPNG::Image
    def to_red_stream
        self.to_rgb_stream.unpack('axx'*(self.to_rgb_stream.length/3)).join
    end

    def to_green_stream
        self.to_rgb_stream.unpack('xax'*(self.to_rgb_stream.length/3)).join
    end

    def to_blue_stream
        self.to_rgb_stream.unpack('xxa'*(self.to_rgb_stream.length/3)).join
    end

    def to_argb_stream
        rgba = self.to_rgba_stream.split("")
        (0..rgba.length-1).step(4).map { |n| "#{rgba[n+3]}#{rgba[n]}#{rgba[n+1]}#{rgba[n+2]}" }.join
    end

    def get_bytes(stream,type)
        if stream == "alpha" then stream = "alpha_channel" end
        values = self.send("to_#{stream}_stream".to_sym).each_byte.map { |n| (n >> type) & 1 }
        values.fill(0,values.length..(8*(values.length/8.0).ceil)-1)
        (0..(values.length)-1).step(8).map { |n| (values[n] << 7 | values[n+1] << 6 | values[n+2] << 5 | values[n+3] << 4 | values[n+4] << 3 | values[n+5] << 2 | values[n+6] << 1 | values[n+7] ).chr  }.join
    end

    [:get_alpha_lsb_bytes,:get_red_lsb_bytes,:get_green_lsb_bytes,:get_blue_lsb_bytes,:get_alpha_msb_bytes,:get_red_msb_bytes,:get_green_msb_bytes,:get_blue_msb_bytes].each { |method|
        define_method(method) {
            method.to_s.split("_")[2] == "lsb" ? self.get_bytes(method.to_s.split("_")[1],0) : self.get_bytes(method.to_s.split("_")[1],7)
        }
    }


end

class String
    def rev_n
        self.each_byte.map { |n| ((n & 0x0F) << 4 | (n & 0xF0) >> 4).chr}.join
    end
    def rev_b
        self.rev_n.reverse
    end
    def decode64
        Base64.decode64(self)
    end
    def encode64
        Base64.strict_encode64(self)
    end
    def reverse64
        Base64.reverse64(self)
    end
    def decrypt(key)
        Toolkit.decrypt(key,self)
    end
    def unmunge(key)
        Toolkit.unmunge(key,self)
    end
    def lookahead(key)
        Toolkit.lookahead(key,self)
    end
    def to_b(mode='b')
        case mode.downcase
        when 'b'
            self.split("").map { |n| n.to_i }.to_b
        when 'h'
            self.to_bin
        end
    end
    def shift_c(value)
        self.each_byte.map { |n| ((n+value)&0xFF).chr }.join
    end
    def shift_k(key)
        key = key.unpack("C*")
        data = self.unpack("C*")
        data.length.times.map { |n| ((data[n] - key[n%key.size])&0xFF) }.pack("C*")
    end
    def shift_p(key)
        data = self.unpack("C*")
        data.length.times.map { |n| ((data[n] - key[n%key.size])&0xFF) }.pack("C*")
    end
    def save(filename)
        IO.binwrite(filename,self)
    end
    def interleave(second)
        self.split("").zip(second.split("")).join
    end
    def to_bin
        Toolkit.to_bin(self)
    end
    def calendar
        Toolkit.calendar(self)
    end
end

class Array
    def to_b
        self.fill(0,self.length..(8*(self.length/8.0).ceil)-1)
        (0..(self.length)-1).step(8).map { |n| (self[n] << 7 | self[n+1] << 6 | self[n+2] << 5 | self[n+3] << 4 | self[n+4] << 3 | self[n+5] << 2 | self[n+6] << 1 | self[n+7] ).chr  }.join
    end
end

module Base64
    def self.analyze(b64)
        (Set.new(b64.split("")) ^ Set.new([*('A'..'Z'),*('a'..'z'),*('0'..'9')]+"+/?=".split("")))
    end
    def self.reverse64(b64)
        Base64.decode64(Base64.encode64(b64).reverse)
    end
end

module Toolkit
    def self.mergeB64(*args)
        (0..args.length-2).each.inject(args[0].split("")) { |n,i| n.zip(args[i+1].split("")) }.map { |n| n.flatten.group_by { |e| e }.values.max_by(&:size).first }.join
    end
    def self.to_bin(hexcode)
        hexcode.scan(/[[:xdigit:]]{2}/).map { |n| n.to_i(16) }.pack("C*")
    end

    def self.calendar(data)
        deltas = [31,59,90,120,151,181,212,243,273,304,334,365]
        out = ""
        count = data.length
        offset = 31
        n = 1
        until offset >= count
            out << data[offset]
            offset = deltas[n%12]+n+(n/12)*365
            n+=1
        end
        return out
    end

    def self.unmunge(key,datanode)
        key = key.split("").map { |n| (n.ord % 10) }
        key += key.reverse[0,key.length-1]
        return (0..(datanode.length/10)-1).each.map { |row| datanode[10*row+key[row % key.size]] }.join
    end

    def self.lookahead(key,datanode)
        size = (datanode.length>>1)
        a = b = k = 0
        key = key.unpack("C*")
        s = key.size
        datanode = datanode.unpack("C*")
        output = []
        out_byte = Hash.new(lambda { |b,key_byte| ((b-key_byte)&0xFF) })
        out_byte[1] = lambda { |b,key_byte| ((b+key_byte)&0xFF) }
        size.times { |i|
            k = key[i % s]
            a = datanode[(i<<1)]
            b = datanode[(i<<1)+1]
            output << out_byte[a&1].call(b,k)
        }
        return output.pack("C*")
    end

    def self.decrypt(key,datanode)
        size = (datanode.length>>1)
        a = b = k = d = 0
        s = key.size
        key = key.unpack("C*")
        datanode = datanode.unpack("C*")
        output = ""
        size.times { |i|
            k = key[i % s]
            d = datanode[(i<<1)]
            a = k & 1
            b = datanode[(i<<1)+1] & 1
            output << (((d + a)<<1)-b-k) % 256
        }
        return output
    end

    def self.encrypt(key,datanode)
        output = ""
        a = b = d = k = 0
        s = key.size
        first_byte = Hash.new(lambda { |byte,b,key_byte| ((byte+b)+(key_byte)>>1) % 256 })
        first_byte[1] =  lambda { |byte,b,key_byte| ((byte-b)+(key_byte)>>1) % 256 }
        second_byte = Hash.new(lambda { (Random.rand(255) & 0xFE) })
        second_byte[1] = lambda { (Random.rand(255) | 1) }
        key = key.unpack("C*")
        datanode = datanode.unpack("C*")
        datanode.length.times { |i|
            k = key[i % s]
            d = datanode[i]
            a = k & 1
            b = d & 1
            output << first_byte[a&b].call(d,b,k) << second_byte[a^b].call
        }
        return output
    end
    def self.combine(*args)
        (0..args.length-2).each.inject(args[0]) { |n,i| n.zip(args[i+1]).map { |x,y| (x.ord|y.ord).chr} }.join
    end

    def self.map(map,values)
        map.each_key { |n| values.gsub!(n,map[n]) }
        if map.max_by { |k,v| v }.last.ord > 1 then
            values = values.unpack("C*")
            (0..(values.length)-1).step(2).map { |n| ((values[n] << 4) | values[n+1]).chr }.join
        else
            values = values.ljust((8*(values.length/8.0).ceil),0x00.chr)
            values = values.unpack("C*")
            (0..(values.length)-1).step(8).map { |n| (values[n] << 7 | values[n+1] << 6 | values[n+2] << 5 | values[n+3] << 4 | values[n+4] << 3 | values[n+5] << 2 | values[n+6] << 1 | values[n+7] ).chr  }.join
        end
    end

    def self.freqs(values)
        counts = Hash.new(0)
        values.each { |n| counts[n] += 1 }
        counts.sort_by { |k,v| v }.reverse
    end

    def self.get_lsb_bytes(values)
        values = values.each_byte.map { |n| n & 1 }
        values.fill(0,values.length..(8*(values.length/8.0).ceil)-1)
        (0..(values.length)-1).step(8).map { |n| (values[n] << 7 | values[n+1] << 6 | values[n+2] << 5 | values[n+3] << 4 | values[n+4] << 3 | values[n+5] << 2 | values[n+6] << 1 | values[n+7] ).chr  }.join
    end
    def self.get_msb_bytes(values)
        values = values.each_byte.map { |n| (n>>7) & 1 }
        values.fill(0,values.length..(8*(values.length/8.0).ceil)-1)
        (0..(values.length)-1).step(8).map { |n| (values[n] << 7 | values[n+1] << 6 | values[n+2] << 5 | values[n+3] << 4 | values[n+4] << 3 | values[n+5] << 2 | values[n+6] << 1 | values[n+7] ).chr  }.join
    end
end

module Morse
    @@m = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----."]
    @@morse = Hash[*(@@m.zip([*('A'..'Z'),*('0'..'9')])).flatten]
    def self.decode(s)
        s.split(" ").map { |n| @@morse[n] }.join
    end
end