Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/PIL/FpxImagePlugin.py: 1%
92 statements
« prev ^ index » next coverage.py v6.4.4, created at 2023-07-17 14:22 -0600
« prev ^ index » next coverage.py v6.4.4, created at 2023-07-17 14:22 -0600
1#
2# THIS IS WORK IN PROGRESS
3#
4# The Python Imaging Library.
5# $Id$
6#
7# FlashPix support for PIL
8#
9# History:
10# 97-01-25 fl Created (reads uncompressed RGB images only)
11#
12# Copyright (c) Secret Labs AB 1997.
13# Copyright (c) Fredrik Lundh 1997.
14#
15# See the README file for information on usage and redistribution.
16#
17import olefile
19from . import Image, ImageFile
20from ._binary import i32le as i32
22# we map from colour field tuples to (mode, rawmode) descriptors
23MODES = {
24 # opacity
25 (0x00007FFE,): ("A", "L"),
26 # monochrome
27 (0x00010000,): ("L", "L"),
28 (0x00018000, 0x00017FFE): ("RGBA", "LA"),
29 # photo YCC
30 (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
31 (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
32 # standard RGB (NIFRGB)
33 (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
34 (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
35}
38#
39# --------------------------------------------------------------------
42def _accept(prefix):
43 return prefix[:8] == olefile.MAGIC
46##
47# Image plugin for the FlashPix images.
50class FpxImageFile(ImageFile.ImageFile):
52 format = "FPX"
53 format_description = "FlashPix"
55 def _open(self):
56 #
57 # read the OLE directory and see if this is a likely
58 # to be a FlashPix file
60 try:
61 self.ole = olefile.OleFileIO(self.fp)
62 except OSError as e:
63 raise SyntaxError("not an FPX file; invalid OLE file") from e
65 if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
66 raise SyntaxError("not an FPX file; bad root CLSID")
68 self._open_index(1)
70 def _open_index(self, index=1):
71 #
72 # get the Image Contents Property Set
74 prop = self.ole.getproperties(
75 [f"Data Object Store {index:06d}", "\005Image Contents"]
76 )
78 # size (highest resolution)
80 self._size = prop[0x1000002], prop[0x1000003]
82 size = max(self.size)
83 i = 1
84 while size > 64:
85 size = size / 2
86 i += 1
87 self.maxid = i - 1
89 # mode. instead of using a single field for this, flashpix
90 # requires you to specify the mode for each channel in each
91 # resolution subimage, and leaves it to the decoder to make
92 # sure that they all match. for now, we'll cheat and assume
93 # that this is always the case.
95 id = self.maxid << 16
97 s = prop[0x2000002 | id]
99 colors = []
100 bands = i32(s, 4)
101 if bands > 4:
102 raise OSError("Invalid number of bands")
103 for i in range(bands):
104 # note: for now, we ignore the "uncalibrated" flag
105 colors.append(i32(s, 8 + i * 4) & 0x7FFFFFFF)
107 self.mode, self.rawmode = MODES[tuple(colors)]
109 # load JPEG tables, if any
110 self.jpeg = {}
111 for i in range(256):
112 id = 0x3000001 | (i << 16)
113 if id in prop:
114 self.jpeg[i] = prop[id]
116 self._open_subimage(1, self.maxid)
118 def _open_subimage(self, index=1, subimage=0):
119 #
120 # setup tile descriptors for a given subimage
122 stream = [
123 f"Data Object Store {index:06d}",
124 f"Resolution {subimage:04d}",
125 "Subimage 0000 Header",
126 ]
128 fp = self.ole.openstream(stream)
130 # skip prefix
131 fp.read(28)
133 # header stream
134 s = fp.read(36)
136 size = i32(s, 4), i32(s, 8)
137 # tilecount = i32(s, 12)
138 tilesize = i32(s, 16), i32(s, 20)
139 # channels = i32(s, 24)
140 offset = i32(s, 28)
141 length = i32(s, 32)
143 if size != self.size:
144 raise OSError("subimage mismatch")
146 # get tile descriptors
147 fp.seek(28 + offset)
148 s = fp.read(i32(s, 12) * length)
150 x = y = 0
151 xsize, ysize = size
152 xtile, ytile = tilesize
153 self.tile = []
155 for i in range(0, len(s), length):
157 x1 = min(xsize, x + xtile)
158 y1 = min(ysize, y + ytile)
160 compression = i32(s, i + 8)
162 if compression == 0:
163 self.tile.append(
164 (
165 "raw",
166 (x, y, x1, y1),
167 i32(s, i) + 28,
168 (self.rawmode,),
169 )
170 )
172 elif compression == 1:
174 # FIXME: the fill decoder is not implemented
175 self.tile.append(
176 (
177 "fill",
178 (x, y, x1, y1),
179 i32(s, i) + 28,
180 (self.rawmode, s[12:16]),
181 )
182 )
184 elif compression == 2:
186 internal_color_conversion = s[14]
187 jpeg_tables = s[15]
188 rawmode = self.rawmode
190 if internal_color_conversion:
191 # The image is stored as usual (usually YCbCr).
192 if rawmode == "RGBA":
193 # For "RGBA", data is stored as YCbCrA based on
194 # negative RGB. The following trick works around
195 # this problem :
196 jpegmode, rawmode = "YCbCrK", "CMYK"
197 else:
198 jpegmode = None # let the decoder decide
200 else:
201 # The image is stored as defined by rawmode
202 jpegmode = rawmode
204 self.tile.append(
205 (
206 "jpeg",
207 (x, y, x1, y1),
208 i32(s, i) + 28,
209 (rawmode, jpegmode),
210 )
211 )
213 # FIXME: jpeg tables are tile dependent; the prefix
214 # data must be placed in the tile descriptor itself!
216 if jpeg_tables:
217 self.tile_prefix = self.jpeg[jpeg_tables]
219 else:
220 raise OSError("unknown/invalid compression")
222 x = x + xtile
223 if x >= xsize:
224 x, y = 0, y + ytile
225 if y >= ysize:
226 break # isn't really required
228 self.stream = stream
229 self.fp = None
231 def load(self):
233 if not self.fp:
234 self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
236 return ImageFile.ImageFile.load(self)
239#
240# --------------------------------------------------------------------
243Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
245Image.register_extension(FpxImageFile.format, ".fpx")