← Back to branch summary

~ubuntu-branches/ubuntu/wily/python-imaging/wily

« back to all changes in this revision

Viewing changes to PIL/IcnsImagePlugin.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-01-31 20:49:20 UTC
  • mfrom: (1.1.4)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130131204920-7tnuhqhlsqdza4c2
Rewrite build dependencies to allow cross builds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
PIL/IcnsImagePlugin.py
14
14
# See the README file for information on usage and redistribution.
15
15
#
16
16
 
17
 
import Image, ImageFile
18
 
import string, struct
 
17
from . import Image, ImageFile, _binary
 
18
import struct
 
19
 
 
20
i8 = _binary.i8
19
21
 
20
22
HEADERSIZE = 8
21
23
 
22
24
def nextheader(fobj):
23
25
    return struct.unpack('>4sI', fobj.read(HEADERSIZE))
24
26
 
25
 
def read_32t(fobj, (start, length), (width, height)):
 
27
def read_32t(fobj, start_length, size):
26
28
    # The 128x128 icon seems to have an extra header for some reason.
 
29
    (start, length) = start_length
27
30
    fobj.seek(start)
28
31
    sig = fobj.read(4)
29
 
    if sig != '\x00\x00\x00\x00':
30
 
        raise SyntaxError, 'Unknown signature, expecting 0x00000000'
31
 
    return read_32(fobj, (start + 4, length - 4), (width, height))
 
32
    if sig != b'\x00\x00\x00\x00':
 
33
        raise SyntaxError('Unknown signature, expecting 0x00000000')
 
34
    return read_32(fobj, (start + 4, length - 4), size)
32
35
 
33
 
def read_32(fobj, (start, length), size):
 
36
def read_32(fobj, start_length, size):
34
37
    """
35
38
    Read a 32bit RGB icon resource.  Seems to be either uncompressed or
36
39
    an RLE packbits-like scheme.
37
40
    """
 
41
    (start, length) = start_length
38
42
    fobj.seek(start)
39
43
    sizesq = size[0] * size[1]
40
44
    if length == sizesq * 3:
51
55
                byte = fobj.read(1)
52
56
                if not byte:
53
57
                    break
54
 
                byte = ord(byte)
 
58
                byte = i8(byte)
55
59
                if byte & 0x80:
56
60
                    blocksize = byte - 125
57
61
                    byte = fobj.read(1)
68
72
                    "Error reading channel [%r left]" % bytesleft
69
73
                    )
70
74
            band = Image.frombuffer(
71
 
                "L", size, string.join(data, ""), "raw", "L", 0, 1
 
75
                "L", size, b"".join(data), "raw", "L", 0, 1
72
76
                )
73
77
            im.im.putband(band.im, band_ix)
74
78
    return {"RGB": im}
75
79
 
76
 
def read_mk(fobj, (start, length), size):
 
80
def read_mk(fobj, start_length, size):
77
81
    # Alpha masks seem to be uncompressed
 
82
    (start, length) = start_length
78
83
    fobj.seek(start)
79
84
    band = Image.frombuffer(
80
85
        "L", size, fobj.read(size[0]*size[1]), "raw", "L", 0, 1
85
90
 
86
91
    SIZES = {
87
92
        (128, 128): [
88
 
            ('it32', read_32t),
89
 
            ('t8mk', read_mk),
 
93
            (b'it32', read_32t),
 
94
            (b't8mk', read_mk),
90
95
        ],
91
96
        (48, 48): [
92
 
            ('ih32', read_32),
93
 
            ('h8mk', read_mk),
 
97
            (b'ih32', read_32),
 
98
            (b'h8mk', read_mk),
94
99
        ],
95
100
        (32, 32): [
96
 
            ('il32', read_32),
97
 
            ('l8mk', read_mk),
 
101
            (b'il32', read_32),
 
102
            (b'l8mk', read_mk),
98
103
        ],
99
104
        (16, 16): [
100
 
            ('is32', read_32),
101
 
            ('s8mk', read_mk),
 
105
            (b'is32', read_32),
 
106
            (b's8mk', read_mk),
102
107
        ],
103
108
    }
104
109
 
111
116
        self.fobj = fobj
112
117
        sig, filesize = nextheader(fobj)
113
118
        if sig != 'icns':
114
 
            raise SyntaxError, 'not an icns file'
 
119
            raise SyntaxError('not an icns file')
115
120
        i = HEADERSIZE
116
121
        while i < filesize:
117
122
            sig, blocksize = nextheader(fobj)
125
130
        sizes = []
126
131
        for size, fmts in self.SIZES.items():
127
132
            for (fmt, reader) in fmts:
128
 
                if self.dct.has_key(fmt):
 
133
                if fmt in self.dct:
129
134
                    sizes.append(size)
130
135
                    break
131
136
        return sizes
133
138
    def bestsize(self):
134
139
        sizes = self.itersizes()
135
140
        if not sizes:
136
 
            raise SyntaxError, "No 32bit icon resources found"
 
141
            raise SyntaxError("No 32bit icon resources found")
137
142
        return max(sizes)
138
143
 
139
144
    def dataforsize(self, size):
201
206
        self.load_end()
202
207
 
203
208
 
204
 
Image.register_open("ICNS", IcnsImageFile, lambda x: x[:4] == 'icns')
 
209
Image.register_open("ICNS", IcnsImageFile, lambda x: x[:4] == b'icns')
205
210
Image.register_extension("ICNS", '.icns')
206
211
 
207
212
if __name__ == '__main__':