Pillow/PIL/IcnsImagePlugin.py

312 lines
9.0 KiB
Python
Raw Normal View History

2010-07-31 06:52:47 +04:00
#
# The Python Imaging Library.
# $Id$
#
# Mac OS X icns file decoder, based on icns.py by Bob Ippolito.
#
# history:
# 2004-10-09 fl Turned into a PIL plugin; removed 2.3 dependencies.
#
# Copyright (c) 2004 by Bob Ippolito.
# Copyright (c) 2004 by Secret Labs.
# Copyright (c) 2004 by Fredrik Lundh.
2014-03-24 20:10:23 +04:00
# Copyright (c) 2014 by Alastair Houghton.
2010-07-31 06:52:47 +04:00
#
# See the README file for information on usage and redistribution.
#
from PIL import Image, ImageFile, PngImagePlugin, _binary
2014-08-26 17:47:10 +04:00
import io
import struct
2010-07-31 06:52:47 +04:00
enable_jpeg2k = hasattr(Image.core, 'jp2klib_version')
if enable_jpeg2k:
2014-03-28 13:30:16 +04:00
from PIL import Jpeg2KImagePlugin
i8 = _binary.i8
2010-07-31 06:52:47 +04:00
HEADERSIZE = 8
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
def nextheader(fobj):
return struct.unpack('>4sI', fobj.read(HEADERSIZE))
2014-08-26 17:47:10 +04:00
def read_32t(fobj, start_length, size):
2010-07-31 06:52:47 +04:00
# The 128x128 icon seems to have an extra header for some reason.
(start, length) = start_length
2010-07-31 06:52:47 +04:00
fobj.seek(start)
sig = fobj.read(4)
if sig != b'\x00\x00\x00\x00':
raise SyntaxError('Unknown signature, expecting 0x00000000')
return read_32(fobj, (start + 4, length - 4), size)
2010-07-31 06:52:47 +04:00
2014-08-26 17:47:10 +04:00
def read_32(fobj, start_length, size):
2010-07-31 06:52:47 +04:00
"""
Read a 32bit RGB icon resource. Seems to be either uncompressed or
an RLE packbits-like scheme.
"""
(start, length) = start_length
2010-07-31 06:52:47 +04:00
fobj.seek(start)
2014-03-24 20:10:23 +04:00
pixel_size = (size[0] * size[2], size[1] * size[2])
sizesq = pixel_size[0] * pixel_size[1]
2010-07-31 06:52:47 +04:00
if length == sizesq * 3:
# uncompressed ("RGBRGBGB")
indata = fobj.read(length)
2014-03-24 20:10:23 +04:00
im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
2010-07-31 06:52:47 +04:00
else:
# decode image
2014-03-24 20:10:23 +04:00
im = Image.new("RGB", pixel_size, None)
2010-07-31 06:52:47 +04:00
for band_ix in range(3):
data = []
bytesleft = sizesq
while bytesleft > 0:
byte = fobj.read(1)
if not byte:
break
byte = i8(byte)
2010-07-31 06:52:47 +04:00
if byte & 0x80:
blocksize = byte - 125
byte = fobj.read(1)
for i in range(blocksize):
data.append(byte)
else:
blocksize = byte + 1
data.append(fobj.read(blocksize))
bytesleft -= blocksize
2010-07-31 06:52:47 +04:00
if bytesleft <= 0:
break
if bytesleft != 0:
raise SyntaxError(
"Error reading channel [%r left]" % bytesleft
)
band = Image.frombuffer(
"L", pixel_size, b"".join(data), "raw", "L", 0, 1
2010-07-31 06:52:47 +04:00
)
im.im.putband(band.im, band_ix)
return {"RGB": im}
2014-08-26 17:47:10 +04:00
def read_mk(fobj, start_length, size):
2010-07-31 06:52:47 +04:00
# Alpha masks seem to be uncompressed
(start, length) = start_length
2010-07-31 06:52:47 +04:00
fobj.seek(start)
2014-03-24 20:10:23 +04:00
pixel_size = (size[0] * size[2], size[1] * size[2])
sizesq = pixel_size[0] * pixel_size[1]
2010-07-31 06:52:47 +04:00
band = Image.frombuffer(
2014-03-24 20:10:23 +04:00
"L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1
2010-07-31 06:52:47 +04:00
)
return {"A": band}
2014-08-26 17:47:10 +04:00
2014-03-24 20:10:23 +04:00
def read_png_or_jpeg2000(fobj, start_length, size):
(start, length) = start_length
fobj.seek(start)
sig = fobj.read(12)
if sig[:8] == b'\x89PNG\x0d\x0a\x1a\x0a':
fobj.seek(start)
im = PngImagePlugin.PngImageFile(fobj)
return {"RGBA": im}
elif sig[:4] == b'\xff\x4f\xff\x51' \
2014-08-26 17:47:10 +04:00
or sig[:4] == b'\x0d\x0a\x87\x0a' \
or sig == b'\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a':
if not enable_jpeg2k:
2014-08-26 17:47:10 +04:00
raise ValueError('Unsupported icon subimage format (rebuild PIL '
'with JPEG 2000 support to fix this)')
2014-03-24 20:10:23 +04:00
# j2k, jpc or j2c
fobj.seek(start)
jp2kstream = fobj.read(length)
f = io.BytesIO(jp2kstream)
im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
if im.mode != 'RGBA':
im = im.convert('RGBA')
return {"RGBA": im}
else:
raise ValueError('Unsupported icon subimage format')
2014-03-24 20:10:23 +04:00
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
class IcnsFile:
SIZES = {
2014-03-24 20:10:23 +04:00
(512, 512, 2): [
(b'ic10', read_png_or_jpeg2000),
],
(512, 512, 1): [
(b'ic09', read_png_or_jpeg2000),
],
(256, 256, 2): [
(b'ic14', read_png_or_jpeg2000),
],
(256, 256, 1): [
(b'ic08', read_png_or_jpeg2000),
],
(128, 128, 2): [
(b'ic13', read_png_or_jpeg2000),
],
(128, 128, 1): [
(b'ic07', read_png_or_jpeg2000),
(b'it32', read_32t),
(b't8mk', read_mk),
2010-07-31 06:52:47 +04:00
],
2014-03-24 20:10:23 +04:00
(64, 64, 1): [
(b'icp6', read_png_or_jpeg2000),
],
(32, 32, 2): [
(b'ic12', read_png_or_jpeg2000),
],
(48, 48, 1): [
(b'ih32', read_32),
(b'h8mk', read_mk),
2010-07-31 06:52:47 +04:00
],
2014-03-24 20:10:23 +04:00
(32, 32, 1): [
(b'icp5', read_png_or_jpeg2000),
(b'il32', read_32),
(b'l8mk', read_mk),
2010-07-31 06:52:47 +04:00
],
2014-03-24 20:10:23 +04:00
(16, 16, 2): [
(b'ic11', read_png_or_jpeg2000),
],
(16, 16, 1): [
(b'icp4', read_png_or_jpeg2000),
(b'is32', read_32),
(b's8mk', read_mk),
2010-07-31 06:52:47 +04:00
],
}
def __init__(self, fobj):
"""
fobj is a file-like object as an icns resource
"""
# signature : (start, length)
self.dct = dct = {}
self.fobj = fobj
sig, filesize = nextheader(fobj)
2014-03-26 15:12:14 +04:00
if sig != b'icns':
raise SyntaxError('not an icns file')
2010-07-31 06:52:47 +04:00
i = HEADERSIZE
while i < filesize:
sig, blocksize = nextheader(fobj)
if blocksize <= 0:
raise SyntaxError('invalid block header')
i += HEADERSIZE
blocksize -= HEADERSIZE
2010-07-31 06:52:47 +04:00
dct[sig] = (i, blocksize)
fobj.seek(blocksize, 1)
i += blocksize
2010-07-31 06:52:47 +04:00
def itersizes(self):
sizes = []
for size, fmts in self.SIZES.items():
for (fmt, reader) in fmts:
if fmt in self.dct:
2010-07-31 06:52:47 +04:00
sizes.append(size)
break
return sizes
def bestsize(self):
sizes = self.itersizes()
if not sizes:
raise SyntaxError("No 32bit icon resources found")
2010-07-31 06:52:47 +04:00
return max(sizes)
def dataforsize(self, size):
"""
Get an icon resource as {channel: array}. Note that
the arrays are bottom-up like windows bitmaps and will likely
need to be flipped or transposed in some way.
"""
dct = {}
for code, reader in self.SIZES[size]:
desc = self.dct.get(code)
if desc is not None:
dct.update(reader(self.fobj, desc, size))
return dct
def getimage(self, size=None):
if size is None:
size = self.bestsize()
2014-03-24 20:10:23 +04:00
if len(size) == 2:
size = (size[0], size[1], 1)
2010-07-31 06:52:47 +04:00
channels = self.dataforsize(size)
2014-03-24 20:10:23 +04:00
im = channels.get('RGBA', None)
if im:
return im
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
im = channels.get("RGB").copy()
try:
im.putalpha(channels["A"])
except KeyError:
pass
return im
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
##
# Image plugin for Mac OS icons.
class IcnsImageFile(ImageFile.ImageFile):
"""
PIL read-only image support for Mac OS .icns files.
Chooses the best resolution, but will possibly load
a different size image if you mutate the size attribute
before calling 'load'.
The info dictionary has a key 'sizes' that is a list
of sizes that the icns file has.
"""
format = "ICNS"
format_description = "Mac OS icns resource"
def _open(self):
self.icns = IcnsFile(self.fp)
self.mode = 'RGBA'
2014-03-24 20:10:23 +04:00
self.best_size = self.icns.bestsize()
self.size = (self.best_size[0] * self.best_size[2],
self.best_size[1] * self.best_size[2])
2010-07-31 06:52:47 +04:00
self.info['sizes'] = self.icns.itersizes()
# Just use this to see if it's loaded or not yet.
self.tile = ('',)
def load(self):
2014-03-24 20:10:23 +04:00
if len(self.size) == 3:
self.best_size = self.size
self.size = (self.best_size[0] * self.best_size[2],
self.best_size[1] * self.best_size[2])
2010-07-31 06:52:47 +04:00
Image.Image.load(self)
if not self.tile:
return
self.load_prepare()
# This is likely NOT the best way to do it, but whatever.
2014-03-24 20:10:23 +04:00
im = self.icns.getimage(self.best_size)
# If this is a PNG or JPEG 2000, it won't be loaded yet
im.load()
2014-08-26 17:47:10 +04:00
2010-07-31 06:52:47 +04:00
self.im = im.im
self.mode = im.mode
self.size = im.size
self.fp = None
self.icns = None
self.tile = ()
self.load_end()
Image.register_open("ICNS", IcnsImageFile, lambda x: x[:4] == b'icns')
2010-07-31 06:52:47 +04:00
Image.register_extension("ICNS", '.icns')
if __name__ == '__main__':
2014-08-26 17:47:10 +04:00
import os
import sys
2014-03-24 20:10:23 +04:00
imf = IcnsImageFile(open(sys.argv[1], 'rb'))
for size in imf.info['sizes']:
imf.size = size
imf.load()
im = imf.im
im.save('out-%s-%s-%s.png' % size)
2010-07-31 06:52:47 +04:00
im = Image.open(open(sys.argv[1], "rb"))
im.save("out.png")
2014-03-24 20:10:23 +04:00
if sys.platform == 'windows':
os.startfile("out.png")