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

1# 

2# The Python Imaging Library 

3# $Id$ 

4# 

5# Adobe PSD 2.5/3.0 file handling 

6# 

7# History: 

8# 1995-09-01 fl Created 

9# 1997-01-03 fl Read most PSD images 

10# 1997-01-18 fl Fixed P and CMYK support 

11# 2001-10-21 fl Added seek/tell support (for layers) 

12# 

13# Copyright (c) 1997-2001 by Secret Labs AB. 

14# Copyright (c) 1995-2001 by Fredrik Lundh 

15# 

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

17# 

18from __future__ import annotations 

19 

20import io 

21from functools import cached_property 

22from typing import IO 

23 

24from . import Image, ImageFile, ImagePalette 

25from ._binary import i8 

26from ._binary import i16be as i16 

27from ._binary import i32be as i32 

28from ._binary import si16be as si16 

29from ._binary import si32be as si32 

30from ._util import DeferredError 

31 

32MODES = { 

33 # (photoshop mode, bits) -> (pil mode, required channels) 

34 (0, 1): ("1", 1), 

35 (0, 8): ("L", 1), 

36 (1, 8): ("L", 1), 

37 (2, 8): ("P", 1), 

38 (3, 8): ("RGB", 3), 

39 (4, 8): ("CMYK", 4), 

40 (7, 8): ("L", 1), # FIXME: multilayer 

41 (8, 8): ("L", 1), # duotone 

42 (9, 8): ("LAB", 3), 

43} 

44 

45 

46# --------------------------------------------------------------------. 

47# read PSD images 

48 

49 

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

51 return prefix.startswith(b"8BPS") 

52 

53 

54## 

55# Image plugin for Photoshop images. 

56 

57 

58class PsdImageFile(ImageFile.ImageFile): 

59 format = "PSD" 

60 format_description = "Adobe Photoshop" 

61 _close_exclusive_fp_after_loading = False 

62 

63 def _open(self) -> None: 

64 assert self.fp is not None 

65 read = self.fp.read 

66 

67 # 

68 # header 

69 

70 s = read(26) 

71 if not _accept(s) or i16(s, 4) != 1: 

72 msg = "not a PSD file" 

73 raise SyntaxError(msg) 

74 

75 psd_bits = i16(s, 22) 

76 psd_channels = i16(s, 12) 

77 psd_mode = i16(s, 24) 

78 

79 mode, channels = MODES[(psd_mode, psd_bits)] 

80 

81 if channels > psd_channels: 

82 msg = "not enough channels" 

83 raise OSError(msg) 

84 if mode == "RGB" and psd_channels == 4: 

85 mode = "RGBA" 

86 channels = 4 

87 

88 self._mode = mode 

89 self._size = i32(s, 18), i32(s, 14) 

90 

91 # 

92 # color mode data 

93 

94 size = i32(read(4)) 

95 if size: 

96 data = read(size) 

97 if mode == "P" and size == 768: 

98 self.palette = ImagePalette.raw("RGB;L", data) 

99 

100 # 

101 # image resources 

102 

103 self.resources = [] 

104 

105 size = i32(read(4)) 

106 if size: 

107 # load resources 

108 end = self.fp.tell() + size 

109 while self.fp.tell() < end: 

110 read(4) # signature 

111 id = i16(read(2)) 

112 name = read(i8(read(1))) 

113 if not (len(name) & 1): 

114 read(1) # padding 

115 data = read(i32(read(4))) 

116 if len(data) & 1: 

117 read(1) # padding 

118 self.resources.append((id, name, data)) 

119 if id == 1039: # ICC profile 

120 self.info["icc_profile"] = data 

121 

122 # 

123 # layer and mask information 

124 

125 self._layers_position = None 

126 

127 size = i32(read(4)) 

128 if size: 

129 end = self.fp.tell() + size 

130 size = i32(read(4)) 

131 if size: 

132 self._layers_position = self.fp.tell() 

133 self._layers_size = size 

134 self.fp.seek(end) 

135 self._n_frames: int | None = None 

136 

137 # 

138 # image descriptor 

139 

140 self.tile = _maketile(self.fp, mode, (0, 0) + self.size, channels) 

141 

142 # keep the file open 

143 self._fp = self.fp 

144 self.frame = 1 

145 self._min_frame = 1 

146 

147 @cached_property 

148 def layers( 

149 self, 

150 ) -> list[tuple[str, str, tuple[int, int, int, int], list[ImageFile._Tile]]]: 

151 layers = [] 

152 if self._layers_position is not None: 

153 if isinstance(self._fp, DeferredError): 

154 raise self._fp.ex 

155 self._fp.seek(self._layers_position) 

156 _layer_data = io.BytesIO(ImageFile._safe_read(self._fp, self._layers_size)) 

157 layers = _layerinfo(_layer_data, self._layers_size) 

158 self._n_frames = len(layers) 

159 return layers 

160 

161 @property 

162 def n_frames(self) -> int: 

163 if self._n_frames is None: 

164 self._n_frames = len(self.layers) 

165 return self._n_frames 

166 

167 @property 

168 def is_animated(self) -> bool: 

169 return len(self.layers) > 1 

170 

171 def seek(self, layer: int) -> None: 

172 if not self._seek_check(layer): 

173 return 

174 if isinstance(self._fp, DeferredError): 

175 raise self._fp.ex 

176 

177 # seek to given layer (1..max) 

178 if layer > len(self.layers): 

179 msg = "no more images in PSD file" 

180 raise EOFError(msg) 

181 _, mode, _, tile = self.layers[layer - 1] 

182 self._mode = mode 

183 self.tile = tile 

184 self.frame = layer 

185 self.fp = self._fp 

186 

187 def tell(self) -> int: 

188 # return layer number (0=image, 1..max=layers) 

189 return self.frame 

190 

191 

192def _layerinfo( 

193 fp: IO[bytes], ct_bytes: int 

194) -> list[tuple[str, str, tuple[int, int, int, int], list[ImageFile._Tile]]]: 

195 # read layerinfo block 

196 layers = [] 

197 

198 def read(size: int) -> bytes: 

199 return ImageFile._safe_read(fp, size) 

200 

201 ct = si16(read(2)) 

202 

203 # sanity check 

204 if ct_bytes < (abs(ct) * 20): 

205 msg = "Layer block too short for number of layers requested" 

206 raise SyntaxError(msg) 

207 

208 for _ in range(abs(ct)): 

209 # bounding box 

210 y0 = si32(read(4)) 

211 x0 = si32(read(4)) 

212 y1 = si32(read(4)) 

213 x1 = si32(read(4)) 

214 

215 # image info 

216 bands = [] 

217 ct_types = i16(read(2)) 

218 if ct_types > 4: 

219 fp.seek(ct_types * 6 + 12, io.SEEK_CUR) 

220 size = i32(read(4)) 

221 fp.seek(size, io.SEEK_CUR) 

222 continue 

223 

224 for _ in range(ct_types): 

225 channel_id = i16(read(2)) 

226 

227 if channel_id == 65535: 

228 b = "A" 

229 elif channel_id < 4: 

230 b = "RGBA"[channel_id] 

231 else: 

232 b = "" 

233 

234 bands.append(b) 

235 read(4) # size 

236 

237 # figure out the image mode 

238 bands.sort() 

239 if bands == ["R"]: 

240 mode = "L" 

241 elif bands == ["B", "G", "R"]: 

242 mode = "RGB" 

243 elif bands == ["A", "B", "G", "R"]: 

244 mode = "RGBA" 

245 else: 

246 mode = "" # unknown 

247 

248 # skip over blend flags and extra information 

249 read(12) # filler 

250 name = "" 

251 size = i32(read(4)) # length of the extra data field 

252 if size: 

253 data_end = fp.tell() + size 

254 

255 length = i32(read(4)) 

256 if length: 

257 fp.seek(length - 16, io.SEEK_CUR) 

258 

259 length = i32(read(4)) 

260 if length: 

261 fp.seek(length, io.SEEK_CUR) 

262 

263 length = i8(read(1)) 

264 if length: 

265 # Don't know the proper encoding, 

266 # Latin-1 should be a good guess 

267 name = read(length).decode("latin-1", "replace") 

268 

269 fp.seek(data_end) 

270 layers.append((name, mode, (x0, y0, x1, y1))) 

271 

272 # get tiles 

273 layerinfo = [] 

274 for i, (name, mode, bbox) in enumerate(layers): 

275 tile = [] 

276 for m in mode: 

277 t = _maketile(fp, m, bbox, 1) 

278 if t: 

279 tile.extend(t) 

280 layerinfo.append((name, mode, bbox, tile)) 

281 

282 return layerinfo 

283 

284 

285def _maketile( 

286 file: IO[bytes], mode: str, bbox: tuple[int, int, int, int], channels: int 

287) -> list[ImageFile._Tile]: 

288 tiles = [] 

289 read = file.read 

290 

291 compression = i16(read(2)) 

292 

293 xsize = bbox[2] - bbox[0] 

294 ysize = bbox[3] - bbox[1] 

295 

296 offset = file.tell() 

297 

298 if compression == 0: 

299 # 

300 # raw compression 

301 for channel in range(channels): 

302 layer = mode[channel] 

303 if mode == "CMYK": 

304 layer += ";I" 

305 tiles.append(ImageFile._Tile("raw", bbox, offset, layer)) 

306 offset = offset + xsize * ysize 

307 

308 elif compression == 1: 

309 # 

310 # packbits compression 

311 i = 0 

312 bytecount = read(channels * ysize * 2) 

313 offset = file.tell() 

314 for channel in range(channels): 

315 layer = mode[channel] 

316 if mode == "CMYK": 

317 layer += ";I" 

318 tiles.append(ImageFile._Tile("packbits", bbox, offset, layer)) 

319 for y in range(ysize): 

320 offset = offset + i16(bytecount, i) 

321 i += 2 

322 

323 file.seek(offset) 

324 

325 if offset & 1: 

326 read(1) # padding 

327 

328 return tiles 

329 

330 

331# -------------------------------------------------------------------- 

332# registry 

333 

334 

335Image.register_open(PsdImageFile.format, PsdImageFile, _accept) 

336 

337Image.register_extension(PsdImageFile.format, ".psd") 

338 

339Image.register_mime(PsdImageFile.format, "image/vnd.adobe.photoshop")