Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/PIL/IcnsImagePlugin.py: 71%

2# The Python Imaging Library.

3# $Id$

5# macOS icns file decoder, based on icns.py by Bob Ippolito.

7# history:

8# 2004-10-09 fl Turned into a PIL plugin; removed 2.3 dependencies.

9# 2020-04-04 Allow saving on all operating systems.

10#

16#

17# See the README file for information on usage and redistribution.

18#

19from __future__ import annotations

21import io

22import os

23import struct

24import sys

25from typing import IO

27from . import Image, ImageFile, PngImagePlugin, features

28from ._deprecate import deprecate

30enable_jpeg2k = features.check_codec("jpg_2000")

31if enable_jpeg2k:

32 from . import Jpeg2KImagePlugin

34MAGIC = b"icns"

35HEADERSIZE = 8

38def nextheader(fobj: IO[bytes]) -> tuple[bytes, int]:

39 return struct.unpack(">4sI", fobj.read(HEADERSIZE))

42def read_32t(

43 fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]

44) -> dict[str, Image.Image]:

45 # The 128x128 icon seems to have an extra header for some reason.

46 (start, length) = start_length

47 fobj.seek(start)

48 sig = fobj.read(4)

49 if sig != b"\x00\x00\x00\x00":

50 msg = "Unknown signature, expecting 0x00000000"

51 raise SyntaxError(msg)

52 return read_32(fobj, (start + 4, length - 4), size)

55def read_32(

56 fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]

57) -> dict[str, Image.Image]:

58 """

59 Read a 32bit RGB icon resource. Seems to be either uncompressed or

60 an RLE packbits-like scheme.

61 """

62 (start, length) = start_length

63 fobj.seek(start)

64 pixel_size = (size[0] * size[2], size[1] * size[2])

65 sizesq = pixel_size[0] * pixel_size[1]

66 if length == sizesq * 3:

67 # uncompressed ("RGBRGBGB")

68 indata = fobj.read(length)

69 im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)

70 else:

71 # decode image

72 im = Image.new("RGB", pixel_size, None)

73 for band_ix in range(3):

74 data = []

75 bytesleft = sizesq

76 while bytesleft > 0:

77 byte = fobj.read(1)

78 if not byte:

79 break

80 byte_int = byte[0]

81 if byte_int & 0x80:

82 blocksize = byte_int - 125

83 byte = fobj.read(1)

84 for i in range(blocksize):

85 data.append(byte)

86 else:

87 blocksize = byte_int + 1

88 data.append(fobj.read(blocksize))

89 bytesleft -= blocksize

90 if bytesleft <= 0:

91 break

92 if bytesleft != 0:

93 msg = f"Error reading channel [{repr(bytesleft)} left]"

94 raise SyntaxError(msg)

95 band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)

96 im.im.putband(band.im, band_ix)

97 return {"RGB": im}

100def read_mk(

101 fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]

102) -> dict[str, Image.Image]:

103 # Alpha masks seem to be uncompressed

104 start = start_length[0]

105 fobj.seek(start)

106 pixel_size = (size[0] * size[2], size[1] * size[2])

107 sizesq = pixel_size[0] * pixel_size[1]

108 band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)

109 return {"A": band}

110

111

112def read_png_or_jpeg2000(

113 fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]

114) -> dict[str, Image.Image]:

115 (start, length) = start_length

116 fobj.seek(start)

117 sig = fobj.read(12)

118

119 im: Image.Image

120 if sig.startswith(b"\x89PNG\x0d\x0a\x1a\x0a"):

121 fobj.seek(start)

122 im = PngImagePlugin.PngImageFile(fobj)

123 Image._decompression_bomb_check(im.size)

124 return {"RGBA": im}

125 elif (

126 sig.startswith((b"\xff\x4f\xff\x51", b"\x0d\x0a\x87\x0a"))

127 or sig == b"\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a"

128 ):

129 if not enable_jpeg2k:

130 msg = (

131 "Unsupported icon subimage format (rebuild PIL "

132 "with JPEG 2000 support to fix this)"

133 )

134 raise ValueError(msg)

135 # j2k, jpc or j2c

136 fobj.seek(start)

137 jp2kstream = fobj.read(length)

138 f = io.BytesIO(jp2kstream)

139 im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)

140 Image._decompression_bomb_check(im.size)

141 if im.mode != "RGBA":

142 im = im.convert("RGBA")

143 return {"RGBA": im}

144 else:

145 msg = "Unsupported icon subimage format"

146 raise ValueError(msg)

147

148

149class IcnsFile:

150 SIZES = {

151 (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],

152 (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],

153 (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],

154 (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],

155 (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],

156 (128, 128, 1): [

157 (b"ic07", read_png_or_jpeg2000),

158 (b"it32", read_32t),

159 (b"t8mk", read_mk),

160 ],

161 (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],

162 (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],

163 (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],

164 (32, 32, 1): [

165 (b"icp5", read_png_or_jpeg2000),

166 (b"il32", read_32),

167 (b"l8mk", read_mk),

168 ],

169 (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],

170 (16, 16, 1): [

171 (b"icp4", read_png_or_jpeg2000),

172 (b"is32", read_32),

173 (b"s8mk", read_mk),

174 ],

175 }

176

177 def __init__(self, fobj: IO[bytes]) -> None:

178 """

179 fobj is a file-like object as an icns resource

180 """

181 # signature : (start, length)

182 self.dct = {}

183 self.fobj = fobj

184 sig, filesize = nextheader(fobj)

185 if not _accept(sig):

186 msg = "not an icns file"

187 raise SyntaxError(msg)

188 i = HEADERSIZE

189 while i < filesize:

190 sig, blocksize = nextheader(fobj)

191 if blocksize <= 0:

192 msg = "invalid block header"

193 raise SyntaxError(msg)

194 i += HEADERSIZE

195 blocksize -= HEADERSIZE

196 self.dct[sig] = (i, blocksize)

197 fobj.seek(blocksize, io.SEEK_CUR)

198 i += blocksize

199

200 def itersizes(self) -> list[tuple[int, int, int]]:

201 sizes = []

202 for size, fmts in self.SIZES.items():

203 for fmt, reader in fmts:

204 if fmt in self.dct:

205 sizes.append(size)

206 break

207 return sizes

208

209 def bestsize(self) -> tuple[int, int, int]:

210 sizes = self.itersizes()

211 if not sizes:

212 msg = "No 32bit icon resources found"

213 raise SyntaxError(msg)

214 return max(sizes)

215

216 def dataforsize(self, size: tuple[int, int, int]) -> dict[str, Image.Image]:

217 """

218 Get an icon resource as {channel: array}. Note that

219 the arrays are bottom-up like windows bitmaps and will likely

220 need to be flipped or transposed in some way.

221 """

222 dct = {}

223 for code, reader in self.SIZES[size]:

224 desc = self.dct.get(code)

225 if desc is not None:

226 dct.update(reader(self.fobj, desc, size))

227 return dct

228

229 def getimage(

230 self, size: tuple[int, int] | tuple[int, int, int] | None = None

231 ) -> Image.Image:

232 if size is None:

233 size = self.bestsize()

234 elif len(size) == 2:

235 size = (size[0], size[1], 1)

236 channels = self.dataforsize(size)

237

238 im = channels.get("RGBA")

239 if im:

240 return im

241

242 im = channels["RGB"].copy()

243 try:

244 im.putalpha(channels["A"])

245 except KeyError:

246 pass

247 return im

248

249

250##

251# Image plugin for Mac OS icons.

252

253

254class IcnsImageFile(ImageFile.ImageFile):

255 """

256 PIL image support for Mac OS .icns files.

257 Chooses the best resolution, but will possibly load

258 a different size image if you mutate the size attribute

259 before calling 'load'.

260

261 The info dictionary has a key 'sizes' that is a list

262 of sizes that the icns file has.

263 """

264

265 format = "ICNS"

266 format_description = "Mac OS icns resource"

267

268 def _open(self) -> None:

269 self.icns = IcnsFile(self.fp)

270 self._mode = "RGBA"

271 self.info["sizes"] = self.icns.itersizes()

272 self.best_size = self.icns.bestsize()

273 self.size = (

274 self.best_size[0] * self.best_size[2],

275 self.best_size[1] * self.best_size[2],

276 )

277

278 @property # type: ignore[override]

279 def size(self) -> tuple[int, int] | tuple[int, int, int]:

280 return self._size

281

282 @size.setter

283 def size(self, value: tuple[int, int] | tuple[int, int, int]) -> None:

284 if len(value) == 3:

285 deprecate("Setting size to (width, height, scale)", 12, "load(scale)")

286 if value in self.info["sizes"]:

287 self._size = value # type: ignore[assignment]

288 return

289 else:

290 # Check that a matching size exists,

291 # or that there is a scale that would create a size that matches

292 for size in self.info["sizes"]:

293 simple_size = size[0] * size[2], size[1] * size[2]

294 scale = simple_size[0] // value[0]

295 if simple_size[1] / value[1] == scale:

296 self._size = value

297 return

298 msg = "This is not one of the allowed sizes of this image"

299 raise ValueError(msg)

300

301 def load(self, scale: int | None = None) -> Image.core.PixelAccess | None:

302 if scale is not None or len(self.size) == 3:

303 if scale is None and len(self.size) == 3:

304 scale = self.size[2]

305 assert scale is not None

306 width, height = self.size[:2]

307 self.size = width * scale, height * scale

308 self.best_size = width, height, scale

309

310 px = Image.Image.load(self)

311 if self._im is not None and self.im.size == self.size:

312 # Already loaded

313 return px

314 self.load_prepare()

315 # This is likely NOT the best way to do it, but whatever.

316 im = self.icns.getimage(self.best_size)

317

318 # If this is a PNG or JPEG 2000, it won't be loaded yet

319 px = im.load()

320

321 self.im = im.im

322 self._mode = im.mode

323 self.size = im.size

324

325 return px

326

327

328def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:

329 """

330 Saves the image as a series of PNG files,

331 that are then combined into a .icns file.

332 """

333 if hasattr(fp, "flush"):

334 fp.flush()

335

336 sizes = {

337 b"ic07": 128,

338 b"ic08": 256,

339 b"ic09": 512,

340 b"ic10": 1024,

341 b"ic11": 32,

342 b"ic12": 64,

343 b"ic13": 256,

344 b"ic14": 512,

345 }

346 provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}

347 size_streams = {}

348 for size in set(sizes.values()):

349 image = (

350 provided_images[size]

351 if size in provided_images

352 else im.resize((size, size))

353 )

354

355 temp = io.BytesIO()

356 image.save(temp, "png")

357 size_streams[size] = temp.getvalue()

358

359 entries = []

360 for type, size in sizes.items():

361 stream = size_streams[size]

362 entries.append((type, HEADERSIZE + len(stream), stream))

363

364 # Header

365 fp.write(MAGIC)

366 file_length = HEADERSIZE # Header

367 file_length += HEADERSIZE + 8 * len(entries) # TOC

368 file_length += sum(entry[1] for entry in entries)

369 fp.write(struct.pack(">i", file_length))

370

371 # TOC

372 fp.write(b"TOC ")

373 fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))

374 for entry in entries:

375 fp.write(entry[0])

376 fp.write(struct.pack(">i", entry[1]))

377

378 # Data

379 for entry in entries:

380 fp.write(entry[0])

381 fp.write(struct.pack(">i", entry[1]))

382 fp.write(entry[2])

383

384 if hasattr(fp, "flush"):

385 fp.flush()

386

387

388def _accept(prefix: bytes) -> bool:

389 return prefix.startswith(MAGIC)

390

391

392Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)

393Image.register_extension(IcnsImageFile.format, ".icns")

394

395Image.register_save(IcnsImageFile.format, _save)

396Image.register_mime(IcnsImageFile.format, "image/icns")

397

398if __name__ == "__main__":

399 if len(sys.argv) < 2:

400 print("Syntax: python3 IcnsImagePlugin.py [file]")

401 sys.exit()

402

403 with open(sys.argv[1], "rb") as fp:

404 imf = IcnsImageFile(fp)

405 for size in imf.info["sizes"]:

406 width, height, scale = imf.size = size

407 imf.save(f"out-{width}-{height}-{scale}.png")

408 with Image.open(sys.argv[1]) as im:

409 im.save("out.png")

410 if sys.platform == "windows":

411 os.startfile("out.png")