Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/pillow-10.4.0-py3.8-linux-x86_64.egg/PIL/PsdImagePlugin.py: 15%

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 

22 

23from . import Image, ImageFile, ImagePalette 

24from ._binary import i8 

25from ._binary import i16be as i16 

26from ._binary import i32be as i32 

27from ._binary import si16be as si16 

28from ._binary import si32be as si32 

29 

30MODES = { 

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

32 (0, 1): ("1", 1), 

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

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

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

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

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

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

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

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

41} 

42 

43 

44# --------------------------------------------------------------------. 

45# read PSD images 

46 

47 

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

49 return prefix[:4] == b"8BPS" 

50 

51 

52## 

53# Image plugin for Photoshop images. 

54 

55 

56class PsdImageFile(ImageFile.ImageFile): 

57 format = "PSD" 

58 format_description = "Adobe Photoshop" 

59 _close_exclusive_fp_after_loading = False 

60 

61 def _open(self) -> None: 

62 read = self.fp.read 

63 

64 # 

65 # header 

66 

67 s = read(26) 

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

69 msg = "not a PSD file" 

70 raise SyntaxError(msg) 

71 

72 psd_bits = i16(s, 22) 

73 psd_channels = i16(s, 12) 

74 psd_mode = i16(s, 24) 

75 

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

77 

78 if channels > psd_channels: 

79 msg = "not enough channels" 

80 raise OSError(msg) 

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

82 mode = "RGBA" 

83 channels = 4 

84 

85 self._mode = mode 

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

87 

88 # 

89 # color mode data 

90 

91 size = i32(read(4)) 

92 if size: 

93 data = read(size) 

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

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

96 

97 # 

98 # image resources 

99 

100 self.resources = [] 

101 

102 size = i32(read(4)) 

103 if size: 

104 # load resources 

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

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

107 read(4) # signature 

108 id = i16(read(2)) 

109 name = read(i8(read(1))) 

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

111 read(1) # padding 

112 data = read(i32(read(4))) 

113 if len(data) & 1: 

114 read(1) # padding 

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

116 if id == 1039: # ICC profile 

117 self.info["icc_profile"] = data 

118 

119 # 

120 # layer and mask information 

121 

122 self._layers_position = None 

123 

124 size = i32(read(4)) 

125 if size: 

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

127 size = i32(read(4)) 

128 if size: 

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

130 self._layers_size = size 

131 self.fp.seek(end) 

132 self._n_frames: int | None = None 

133 

134 # 

135 # image descriptor 

136 

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

138 

139 # keep the file open 

140 self._fp = self.fp 

141 self.frame = 1 

142 self._min_frame = 1 

143 

144 @cached_property 

145 def layers(self): 

146 layers = [] 

147 if self._layers_position is not None: 

148 self._fp.seek(self._layers_position) 

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

150 layers = _layerinfo(_layer_data, self._layers_size) 

151 self._n_frames = len(layers) 

152 return layers 

153 

154 @property 

155 def n_frames(self) -> int: 

156 if self._n_frames is None: 

157 self._n_frames = len(self.layers) 

158 return self._n_frames 

159 

160 @property 

161 def is_animated(self) -> bool: 

162 return len(self.layers) > 1 

163 

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

165 if not self._seek_check(layer): 

166 return 

167 

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

169 try: 

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

171 self._mode = mode 

172 self.tile = tile 

173 self.frame = layer 

174 self.fp = self._fp 

175 except IndexError as e: 

176 msg = "no such layer" 

177 raise EOFError(msg) from e 

178 

179 def tell(self) -> int: 

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

181 return self.frame 

182 

183 

184def _layerinfo(fp, ct_bytes): 

185 # read layerinfo block 

186 layers = [] 

187 

188 def read(size): 

189 return ImageFile._safe_read(fp, size) 

190 

191 ct = si16(read(2)) 

192 

193 # sanity check 

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

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

196 raise SyntaxError(msg) 

197 

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

199 # bounding box 

200 y0 = si32(read(4)) 

201 x0 = si32(read(4)) 

202 y1 = si32(read(4)) 

203 x1 = si32(read(4)) 

204 

205 # image info 

206 mode = [] 

207 ct_types = i16(read(2)) 

208 if ct_types > 4: 

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

210 size = i32(read(4)) 

211 fp.seek(size, io.SEEK_CUR) 

212 continue 

213 

214 for _ in range(ct_types): 

215 type = i16(read(2)) 

216 

217 if type == 65535: 

218 m = "A" 

219 else: 

220 m = "RGBA"[type] 

221 

222 mode.append(m) 

223 read(4) # size 

224 

225 # figure out the image mode 

226 mode.sort() 

227 if mode == ["R"]: 

228 mode = "L" 

229 elif mode == ["B", "G", "R"]: 

230 mode = "RGB" 

231 elif mode == ["A", "B", "G", "R"]: 

232 mode = "RGBA" 

233 else: 

234 mode = None # unknown 

235 

236 # skip over blend flags and extra information 

237 read(12) # filler 

238 name = "" 

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

240 if size: 

241 data_end = fp.tell() + size 

242 

243 length = i32(read(4)) 

244 if length: 

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

246 

247 length = i32(read(4)) 

248 if length: 

249 fp.seek(length, io.SEEK_CUR) 

250 

251 length = i8(read(1)) 

252 if length: 

253 # Don't know the proper encoding, 

254 # Latin-1 should be a good guess 

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

256 

257 fp.seek(data_end) 

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

259 

260 # get tiles 

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

262 tile = [] 

263 for m in mode: 

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

265 if t: 

266 tile.extend(t) 

267 layers[i] = name, mode, bbox, tile 

268 

269 return layers 

270 

271 

272def _maketile(file, mode, bbox, channels): 

273 tile = None 

274 read = file.read 

275 

276 compression = i16(read(2)) 

277 

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

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

280 

281 offset = file.tell() 

282 

283 if compression == 0: 

284 # 

285 # raw compression 

286 tile = [] 

287 for channel in range(channels): 

288 layer = mode[channel] 

289 if mode == "CMYK": 

290 layer += ";I" 

291 tile.append(("raw", bbox, offset, layer)) 

292 offset = offset + xsize * ysize 

293 

294 elif compression == 1: 

295 # 

296 # packbits compression 

297 i = 0 

298 tile = [] 

299 bytecount = read(channels * ysize * 2) 

300 offset = file.tell() 

301 for channel in range(channels): 

302 layer = mode[channel] 

303 if mode == "CMYK": 

304 layer += ";I" 

305 tile.append(("packbits", bbox, offset, layer)) 

306 for y in range(ysize): 

307 offset = offset + i16(bytecount, i) 

308 i += 2 

309 

310 file.seek(offset) 

311 

312 if offset & 1: 

313 read(1) # padding 

314 

315 return tile 

316 

317 

318# -------------------------------------------------------------------- 

319# registry 

320 

321 

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

323 

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

325 

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