Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.10/site-packages/pillow-11.0.0-py3.10-linux-x86_64.egg/PIL/PsdImagePlugin.py: 16%

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 

30 

31MODES = { 

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

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

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

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

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

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

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

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

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

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

42} 

43 

44 

45# --------------------------------------------------------------------. 

46# read PSD images 

47 

48 

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

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

51 

52 

53## 

54# Image plugin for Photoshop images. 

55 

56 

57class PsdImageFile(ImageFile.ImageFile): 

58 format = "PSD" 

59 format_description = "Adobe Photoshop" 

60 _close_exclusive_fp_after_loading = False 

61 

62 def _open(self) -> None: 

63 read = self.fp.read 

64 

65 # 

66 # header 

67 

68 s = read(26) 

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

70 msg = "not a PSD file" 

71 raise SyntaxError(msg) 

72 

73 psd_bits = i16(s, 22) 

74 psd_channels = i16(s, 12) 

75 psd_mode = i16(s, 24) 

76 

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

78 

79 if channels > psd_channels: 

80 msg = "not enough channels" 

81 raise OSError(msg) 

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

83 mode = "RGBA" 

84 channels = 4 

85 

86 self._mode = mode 

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

88 

89 # 

90 # color mode data 

91 

92 size = i32(read(4)) 

93 if size: 

94 data = read(size) 

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

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

97 

98 # 

99 # image resources 

100 

101 self.resources = [] 

102 

103 size = i32(read(4)) 

104 if size: 

105 # load resources 

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

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

108 read(4) # signature 

109 id = i16(read(2)) 

110 name = read(i8(read(1))) 

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

112 read(1) # padding 

113 data = read(i32(read(4))) 

114 if len(data) & 1: 

115 read(1) # padding 

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

117 if id == 1039: # ICC profile 

118 self.info["icc_profile"] = data 

119 

120 # 

121 # layer and mask information 

122 

123 self._layers_position = None 

124 

125 size = i32(read(4)) 

126 if size: 

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

128 size = i32(read(4)) 

129 if size: 

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

131 self._layers_size = size 

132 self.fp.seek(end) 

133 self._n_frames: int | None = None 

134 

135 # 

136 # image descriptor 

137 

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

139 

140 # keep the file open 

141 self._fp = self.fp 

142 self.frame = 1 

143 self._min_frame = 1 

144 

145 @cached_property 

146 def layers( 

147 self, 

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

149 layers = [] 

150 if self._layers_position is not None: 

151 self._fp.seek(self._layers_position) 

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

153 layers = _layerinfo(_layer_data, self._layers_size) 

154 self._n_frames = len(layers) 

155 return layers 

156 

157 @property 

158 def n_frames(self) -> int: 

159 if self._n_frames is None: 

160 self._n_frames = len(self.layers) 

161 return self._n_frames 

162 

163 @property 

164 def is_animated(self) -> bool: 

165 return len(self.layers) > 1 

166 

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

168 if not self._seek_check(layer): 

169 return 

170 

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

172 try: 

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

174 self._mode = mode 

175 self.tile = tile 

176 self.frame = layer 

177 self.fp = self._fp 

178 except IndexError as e: 

179 msg = "no such layer" 

180 raise EOFError(msg) from e 

181 

182 def tell(self) -> int: 

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

184 return self.frame 

185 

186 

187def _layerinfo( 

188 fp: IO[bytes], ct_bytes: int 

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

190 # read layerinfo block 

191 layers = [] 

192 

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

194 return ImageFile._safe_read(fp, size) 

195 

196 ct = si16(read(2)) 

197 

198 # sanity check 

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

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

201 raise SyntaxError(msg) 

202 

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

204 # bounding box 

205 y0 = si32(read(4)) 

206 x0 = si32(read(4)) 

207 y1 = si32(read(4)) 

208 x1 = si32(read(4)) 

209 

210 # image info 

211 bands = [] 

212 ct_types = i16(read(2)) 

213 if ct_types > 4: 

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

215 size = i32(read(4)) 

216 fp.seek(size, io.SEEK_CUR) 

217 continue 

218 

219 for _ in range(ct_types): 

220 type = i16(read(2)) 

221 

222 if type == 65535: 

223 b = "A" 

224 else: 

225 b = "RGBA"[type] 

226 

227 bands.append(b) 

228 read(4) # size 

229 

230 # figure out the image mode 

231 bands.sort() 

232 if bands == ["R"]: 

233 mode = "L" 

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

235 mode = "RGB" 

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

237 mode = "RGBA" 

238 else: 

239 mode = "" # unknown 

240 

241 # skip over blend flags and extra information 

242 read(12) # filler 

243 name = "" 

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

245 if size: 

246 data_end = fp.tell() + size 

247 

248 length = i32(read(4)) 

249 if length: 

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

251 

252 length = i32(read(4)) 

253 if length: 

254 fp.seek(length, io.SEEK_CUR) 

255 

256 length = i8(read(1)) 

257 if length: 

258 # Don't know the proper encoding, 

259 # Latin-1 should be a good guess 

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

261 

262 fp.seek(data_end) 

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

264 

265 # get tiles 

266 layerinfo = [] 

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

268 tile = [] 

269 for m in mode: 

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

271 if t: 

272 tile.extend(t) 

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

274 

275 return layerinfo 

276 

277 

278def _maketile( 

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

280) -> list[ImageFile._Tile]: 

281 tiles = [] 

282 read = file.read 

283 

284 compression = i16(read(2)) 

285 

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

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

288 

289 offset = file.tell() 

290 

291 if compression == 0: 

292 # 

293 # raw compression 

294 for channel in range(channels): 

295 layer = mode[channel] 

296 if mode == "CMYK": 

297 layer += ";I" 

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

299 offset = offset + xsize * ysize 

300 

301 elif compression == 1: 

302 # 

303 # packbits compression 

304 i = 0 

305 bytecount = read(channels * ysize * 2) 

306 offset = file.tell() 

307 for channel in range(channels): 

308 layer = mode[channel] 

309 if mode == "CMYK": 

310 layer += ";I" 

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

312 for y in range(ysize): 

313 offset = offset + i16(bytecount, i) 

314 i += 2 

315 

316 file.seek(offset) 

317 

318 if offset & 1: 

319 read(1) # padding 

320 

321 return tiles 

322 

323 

324# -------------------------------------------------------------------- 

325# registry 

326 

327 

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

329 

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

331 

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