ref: a24a39793c7672eabd8ddd6666a28f498e994935
dir: /tools/pic.py/
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
A library for use with compressed monster and trainer pics in pokered.
"""
from __future__ import absolute_import
from __future__ import division
import os
import sys
import argparse
from math import sqrt
from pokemontools import gfx
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 = gfx.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 = gfx.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()