pic.py

# coding: utf-8

"""
A library for use with compressed monster and trainer pics in pokered.
"""

import os
import sys
import argparse
from math import sqrt

from gfx import transpose_tiles


def bitflip(x, n):
    r = 0
    while n:
        r = (r << 1) | (x & 1)
        x >>= 1
        n -= 1
    return r


class Decompressor:
    """
    pokered pic decompression.

    Ported to python 2.7 from the python 3 code at https://github.com/magical/pokemon-sprites-rby.
    """

    table1 = [(2 << i) - 1 for i in range(16)]
    table2 = [
        [0x0, 0x1, 0x3, 0x2, 0x7, 0x6, 0x4, 0x5, 0xf, 0xe, 0xc, 0xd, 0x8, 0x9, 0xb, 0xa],
        [0xf, 0xe, 0xc, 0xd, 0x8, 0x9, 0xb, 0xa, 0x0, 0x1, 0x3, 0x2, 0x7, 0x6, 0x4, 0x5], # prev ^ 0xf
        [0x0, 0x8, 0xc, 0x4, 0xe, 0x6, 0x2, 0xa, 0xf, 0x7, 0x3, 0xb, 0x1, 0x9, 0xd, 0x5],
        [0xf, 0x7, 0x3, 0xb, 0x1, 0x9, 0xd, 0x5, 0x0, 0x8, 0xc, 0x4, 0xe, 0x6, 0x2, 0xa], # prev ^ 0xf
    ]
    table3 = [bitflip(i, 4) for i in range(16)]

    tilesize = 8


    def __init__(self, f, mirror=False, planar=True):
        self.bs = fbitstream(f)
        self.mirror = mirror
        self.planar = planar
        self.data = None

    def decompress(self):
        rams = [[], []]

        self.sizex  = self._readint(4) * self.tilesize
        self.sizey  = self._readint(4)

        self.size = self.sizex * self.sizey

        self.ramorder = self._readbit()

        r1 = self.ramorder
        r2 = self.ramorder ^ 1

        self._fillram(rams[r1])
        mode = self._readbit()
        if mode:
            mode += self._readbit()
        self._fillram(rams[r2])

        rams[0] = bytearray(bitgroups_to_bytes(rams[0]))
        rams[1] = bytearray(bitgroups_to_bytes(rams[1]))

        if mode == 0:
            self._decode(rams[0])
            self._decode(rams[1])
        elif mode == 1:
            self._decode(rams[r1])
            self._xor(rams[r1], rams[r2])
        elif mode == 2:
            self._decode(rams[r2], mirror=False)
            self._decode(rams[r1])
            self._xor(rams[r1], rams[r2])
        else:
            raise Exception("Invalid deinterlace mode!")

        data = []
        if self.planar:
            for a, b in zip(rams[0], rams[1]):
                data += [a, b]
            self.data = bytearray(data)
        else:
            for a, b in zip(bitstream(rams[0]), bitstream(rams[1])):
                data.append(a | (b << 1))
            self.data = bitgroups_to_bytes(data)

    def _fillram(self, ram):
        mode = ['rle', 'data'][self._readbit()]
        size = self.size * 4
        while len(ram) < size:
            if mode == 'rle':
                self._read_rle_chunk(ram)
                mode = 'data'
            elif mode == 'data':
                self._read_data_chunk(ram, size)
                mode = 'rle'
        if len(ram) > size:
            #ram = ram[:size]
            raise ValueError(size, len(ram))

        ram[:] = self._deinterlace_bitgroups(ram)

    def _read_rle_chunk(self, ram):

        i = 0
        while self._readbit():
            i += 1

        n = self.table1[i]
        a = self._readint(i + 1)
        n += a

        for i in range(n):
            ram.append(0)

    def _read_data_chunk(self, ram, size):
        while 1:
            bitgroup = self._readint(2)
            if bitgroup == 0:
                break
            ram.append(bitgroup)

            if size <= len(ram):
                break

    def _decode(self, ram, mirror=None):
        if mirror is None:
            mirror = self.mirror

        for x in range(self.sizex):
            bit = 0
            for y in range(self.sizey):
                i = y * self.sizex + x
                a = (ram[i] >> 4) & 0xf
                b = ram[i] & 0xf

                a = self.table2[bit][a]
                bit = a & 1
                if mirror:
                    a = self.table3[a]

                b = self.table2[bit][b]
                bit = b & 1
                if mirror:
                    b = self.table3[b]

                ram[i] = (a << 4) | b

    def _xor(self, ram1, ram2, mirror=None):
        if mirror is None:
            mirror = self.mirror

        for i in range(len(ram2)):
            if mirror:
                a = (ram2[i] >> 4) & 0xf
                b = ram2[i] & 0xf
                a = self.table3[a]
                b = self.table3[b]
                ram2[i] = (a << 4) | b

            ram2[i] ^= ram1[i]

    def _deinterlace_bitgroups(self, bits):
        l = []
        for y in range(self.sizey):
            for x in range(self.sizex):
                i = 4 * y * self.sizex + x
                for j in range(4):
                    l.append(bits[i])
                    i += self.sizex
        return l


    def _readbit(self):
        return next(self.bs)

    def _readint(self, count):
        return readint(self.bs, count)


def fbitstream(f):
    while 1:
        char = f.read(1)
        if not char:
            break
        byte = ord(char)

        for i in range(7, -1, -1):
            yield (byte >> i) & 1

def bitstream(b):
    for byte in b:
        for i in range(7, -1, -1):
            yield (byte >> i) & 1

def readint(bs, count):
    n = 0
    while count:
        n <<= 1
        n |= next(bs)
        count -= 1
    return n

def bitgroups_to_bytes(bits):
    l = []
    for i in range(0, len(bits) - 3, 4):
        n = ((bits[i + 0] << 6)
           | (bits[i + 1] << 4)
           | (bits[i + 2] << 2)
           | (bits[i + 3] << 0))
        l.append(n)
    return bytearray(l)


def bytes_to_bits(bytelist):
    return list(bitstream(bytelist))


class Compressor:
    """
    pokered pic compression.

    Adapted from stag019's C compressor.
    """

    table1 = [(2 << i) - 1 for i in range(16)]
    table2 = [
        [0x0, 0x1, 0x3, 0x2, 0x6, 0x7, 0x5, 0x4, 0xc, 0xd, 0xf, 0xe, 0xa, 0xb, 0x9, 0x8],
        [0x8, 0x9, 0xb, 0xa, 0xe, 0xf, 0xd, 0xc, 0x4, 0x5, 0x7, 0x6, 0x2, 0x3, 0x1, 0x0], # reverse
    ]
    table3 = [bitflip(i, 4) for i in range(16)]

    def __init__(self, image, width=None, height=None):
        self.image = bytearray(image)
        self.size = len(self.image)

        planar_tile = 8 * 8 // 4
        tile_size = self.size // planar_tile
        if   height    and not width:  width  = tile_size // height
        elif width     and not height: height = tile_size // width
        elif not width and not height: width = height = int(sqrt(tile_size))
        self.width, self.height = width, height

    def compress(self):
        """
        Compress the image five times (twice for each mode, except 0)
        and use the smallest one (in bits).
        """
        rams = [[],[]]
        datas = []

        for mode in range(3):

            # Order is redundant for mode 0.

            # While this seems like an optimization,
            # it's actually required for 1:1 compression
            # to the original compressed pics.

            # This appears to be the algorithm
            # that Game Freak's compressor used.

            # Using order 0 instead of 1 breaks this feature.

            for order in range(2):
                if mode == 0 and order == 0:
                    continue
                for i in range(2):
                    rams[i] = self.image[i::2]
                self._interpret_compress(rams, mode, order)
                datas += [(self.data[:], int(self.which_bit))]

        # Pick the smallest pic, measured in bits.
        datas = sorted(datas, key=lambda data_bit: (len(data_bit[0]), -data_bit[1]))
        self.data, self.which_bit = datas[0]

    def _interpret_compress(self, rams, mode, order):
        self.data = []
        self.which_bit = 0

        r1 = order
        r2 = order ^ 1

        if mode == 0:
            self._encode(rams[1])
            self._encode(rams[0])
        elif mode == 1:
            self._xor(rams[r1], rams[r2])
            self._encode(rams[r1])
        elif mode == 2:
            self._xor(rams[r1], rams[r2])
            self._encode(rams[r1])
            self._encode(rams[r2], mirror=False)
        else:
            raise Exception('invalid interlace mode!')

        self._writeint(self.height, 4)
        self._writeint(self.width,  4)

        self._writebit(order)

        self._fillram(rams[r1])
        if mode == 0:
            self._writebit(0)
        else:
            self._writebit(1)
            self._writebit(mode - 1)
        self._fillram(rams[r2])

    def _fillram(self, ram):
        rle = 0
        nums = 0
        bitgroups = []

        for x in range(self.width):
            for bit in range(0, 8, 2):
                byte = x * self.height * 8
                for y in range(self.height * 8):
                    bitgroup = (ram[byte] >> (6 - bit)) & 3
                    if bitgroup == 0:
                        if rle == 0:
                            self._writebit(0)
                        elif rle == 1:
                            nums += 1
                        else:
                            self._data_packet(bitgroups)
                            self._writebit(0)
                            self._writebit(0)
                        rle = 1
                        bitgroups = []
                    else:
                        if rle == 0:
                            self._writebit(1)
                        elif rle == 1:
                            self._rle(nums)
                        rle = -1
                        bitgroups += [bitgroup]
                        nums = 0
                    byte += 1

        if rle == 1:
            self._rle(nums)
        else:
            self._data_packet(bitgroups)

    def _data_packet(self, bitgroups):
        for bitgroup in bitgroups:
            self._writebit((bitgroup >> 1) & 1)
            self._writebit((bitgroup >> 0) & 1)

    def _rle(self, nums):
        nums += 1

        # Get the previous power of 2.
        # Deriving the bitcount from that seems to be
        # faster on average than using the lookup table.
        v = nums
        v += 1
        v |= v >> 1
        v |= v >> 2
        v |= v >> 4
        v |= v >> 8
        v |= v >> 16
        v -= v >> 1
        v -= 1
        number = nums - v

        bitcount = -1
        while v:
            v >>= 1
            bitcount += 1

        for j in range(bitcount):
            self._writebit(1)
        self._writebit(0)
        for j in range(bitcount, -1, -1):
            self._writebit((number >> j) & 1)

    def _encode(self, ram, mirror=None):
        a = b = 0
        for i in range(len(ram)):
            j = i // self.height
            j += i % self.height * self.width * 8
            if i % self.height == 0:
                b = 0

            a = (ram[j] >> 4) & 0xf
            table = b & 1
            code_1 = self.table2[table][a]

            b = ram[j] & 0xf
            table = a & 1
            code_2 = self.table2[table][b]

            ram[j] = (code_1 << 4) | code_2

    def _xor(self, ram1, ram2):
        for i in range(len(ram2)):
            ram2[i] ^= ram1[i]

    def _writebit(self, bit):
        self.which_bit -= 1
        if self.which_bit == -1:
            self.which_bit = 7
            self.data += [0]
        if bit: self.data[-1] |= bit << self.which_bit

    def _writeint(self, num, size=None):
        bits = []
        if size:
            for i in range(size):
                bits += [num & 1]
                num >>= 1
        else:
            while num > 0:
                bits += [num & 1]
                num >>= 1
        for bit in reversed(bits):
            self._writebit(bit)


def decompress(f, offset=None, mirror=False):
    """
    Decompress a pic given a file object. Return a planar 2bpp image.

    Optional: offset (for roms).
    """
    if offset is not None:
        f.seek(offset)
    dcmp = Decompressor(f, mirror=mirror)
    dcmp.decompress()
    return dcmp.data


def compress(f):
    """
    Compress a planar 2bpp into a pic.
    """
    comp = Compressor(f)
    comp.compress()
    return comp.data


def decompress_file(filename):
    """
    Decompress a pic given a filename.
    Export the resulting planar 2bpp image to
    """
    pic = open(filename, 'rb')
    image = decompress(pic)
    image = transpose_tiles(image)
    image = bytearray(image)
    output_filename = os.path.splitext(filename)[0] + '.2bpp'
    with open(output_filename, 'wb') as out:
        out.write(image)

def compress_file(filename):
    image = open(filename, 'rb').read()
    image = transpose_tiles(image)
    pic = compress(image)
    pic = bytearray(pic)
    output_filename = os.path.splitext(filename)[0] + '.pic'
    with open(output_filename, 'wb') as out:
        out.write(pic)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('mode')
    ap.add_argument('filenames', nargs='*')
    args = ap.parse_args()

    for filename in args.filenames:
        if args.mode == 'decompress':
            decompress_file(filename)
        elif args.mode == 'compress':
            compress_file(filename)

if __name__ == '__main__':
    main()