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

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 

20__lazy_modules__ = {"PIL._binary", "PIL._util", "io"} 

21 

22import io 

23from functools import cached_property 

24from typing import NamedTuple 

25 

26from . import Image, ImageFile, ImagePalette 

27from ._binary import i8 

28from ._binary import i16be as i16 

29from ._binary import i32be as i32 

30from ._binary import si16be as si16 

31from ._binary import si32be as si32 

32from ._util import DeferredError 

33 

34TYPE_CHECKING = False 

35if TYPE_CHECKING: 

36 from typing import IO 

37 

38MODES = { 

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

40 (0, 1): ("1", 1), 

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

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

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

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

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

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

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

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

49} 

50 

51 

52class _Layer(NamedTuple): 

53 name: str 

54 mode: str 

55 box: tuple[int, int, int, int] 

56 tile: list[ImageFile._Tile] 

57 

58 

59# --------------------------------------------------------------------. 

60# read PSD images 

61 

62 

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

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

65 

66 

67## 

68# Image plugin for Photoshop images. 

69 

70 

71class PsdImageFile(ImageFile.ImageFile): 

72 format = "PSD" 

73 format_description = "Adobe Photoshop" 

74 _close_exclusive_fp_after_loading = False 

75 

76 def _open(self) -> None: 

77 assert self.fp is not None 

78 read = self.fp.read 

79 

80 # 

81 # header 

82 

83 s = read(26) 

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

85 msg = "not a PSD file" 

86 raise SyntaxError(msg) 

87 

88 psd_bits = i16(s, 22) 

89 psd_channels = i16(s, 12) 

90 psd_mode = i16(s, 24) 

91 

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

93 

94 if channels > psd_channels: 

95 msg = "not enough channels" 

96 raise OSError(msg) 

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

98 mode = "RGBA" 

99 channels = 4 

100 

101 self._mode = mode 

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

103 

104 # 

105 # color mode data 

106 

107 size = i32(read(4)) 

108 if size: 

109 data = read(size) 

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

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

112 

113 # 

114 # image resources 

115 

116 self.resources = [] 

117 

118 size = i32(read(4)) 

119 if size: 

120 # load resources 

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

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

123 read(4) # signature 

124 id = i16(read(2)) 

125 name = read(i8(read(1))) 

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

127 read(1) # padding 

128 data = read(i32(read(4))) 

129 if len(data) & 1: 

130 read(1) # padding 

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

132 if id == 1039: # ICC profile 

133 self.info["icc_profile"] = data 

134 

135 # 

136 # layer and mask information 

137 

138 self._layers_position = None 

139 

140 size = i32(read(4)) 

141 if size: 

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

143 size = i32(read(4)) 

144 if size: 

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

146 self._layers_size = size 

147 self.fp.seek(end) 

148 self._n_frames: int | None = None 

149 

150 # 

151 # image descriptor 

152 

153 self.tile = _maketile(self.fp, mode, (0, 0, *self.size), channels) 

154 

155 # keep the file open 

156 self._fp = self.fp 

157 self.frame = 1 

158 self._min_frame = 1 

159 

160 @cached_property 

161 def layers(self) -> list[_Layer]: 

162 layers = [] 

163 if self._layers_position is not None: 

164 if isinstance(self._fp, DeferredError): 

165 raise self._fp.ex 

166 self._fp.seek(self._layers_position) 

167 layers = _layerinfo(self._fp, self._layers_size) 

168 self._n_frames = len(layers) 

169 return layers 

170 

171 @property 

172 def n_frames(self) -> int: 

173 if self._n_frames is None: 

174 self._n_frames = len(self.layers) 

175 return self._n_frames 

176 

177 @property 

178 def is_animated(self) -> bool: 

179 return len(self.layers) > 1 

180 

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

182 if not self._seek_check(layer): 

183 return 

184 if isinstance(self._fp, DeferredError): 

185 raise self._fp.ex 

186 

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

188 if layer > len(self.layers): 

189 msg = "no more images in PSD file" 

190 raise EOFError(msg) 

191 _, self._mode, _, self.tile = self.layers[layer - 1] 

192 self.frame = layer 

193 self.fp = self._fp 

194 Image.Image.seek(self, layer) 

195 

196 def tell(self) -> int: 

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

198 return self.frame 

199 

200 

201def _layerinfo(fp: IO[bytes], ct_bytes: int) -> list[_Layer]: 

202 # read layerinfo block 

203 layers = [] 

204 

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

206 return ImageFile._safe_read(fp, size) 

207 

208 ct = si16(read(2)) 

209 

210 # sanity check 

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

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

213 raise SyntaxError(msg) 

214 

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

216 # bounding box 

217 y0 = si32(read(4)) 

218 x0 = si32(read(4)) 

219 y1 = si32(read(4)) 

220 x1 = si32(read(4)) 

221 

222 # image info 

223 bands = set() 

224 ct_types = i16(read(2)) 

225 if ct_types > 4: 

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

227 size = i32(read(4)) 

228 fp.seek(size, io.SEEK_CUR) 

229 continue 

230 

231 for _ in range(ct_types): 

232 channel_id = i16(read(2)) 

233 

234 if channel_id == 65535: 

235 b = "A" 

236 elif channel_id < 4: 

237 b = "RGBA"[channel_id] 

238 else: 

239 b = "" 

240 

241 bands.add(b) 

242 read(4) # size 

243 

244 # figure out the image mode 

245 if bands == {"R"}: 

246 mode = "L" 

247 elif bands == {"R", "G", "B"}: 

248 mode = "RGB" 

249 elif bands == {"R", "G", "B", "A"}: 

250 mode = "RGBA" 

251 else: 

252 mode = "" # unknown 

253 

254 # skip over blend flags and extra information 

255 read(12) # filler 

256 name = "" 

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

258 if size: 

259 data_end = fp.tell() + size 

260 

261 length = i32(read(4)) 

262 if length: 

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

264 

265 length = i32(read(4)) 

266 if length: 

267 fp.seek(length, io.SEEK_CUR) 

268 

269 length = i8(read(1)) 

270 if length: 

271 # Don't know the proper encoding, 

272 # Latin-1 should be a good guess 

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

274 

275 fp.seek(data_end) 

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

277 

278 # get tiles 

279 layerinfo = [] 

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

281 tile = [] 

282 for m in mode: 

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

284 if t: 

285 tile.extend(t) 

286 layerinfo.append(_Layer(name, mode, bbox, tile)) 

287 

288 return layerinfo 

289 

290 

291def _maketile( 

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

293) -> list[ImageFile._Tile]: 

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

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

296 if xsize < 0 or ysize < 0: 

297 msg = "negative tile size" 

298 raise ValueError(msg) 

299 

300 tiles = [] 

301 compression = i16(file.read(2)) 

302 offset = file.tell() 

303 if compression == 0: 

304 # 

305 # raw compression 

306 for channel in range(channels): 

307 layer = mode[channel] 

308 if mode == "CMYK": 

309 layer += ";I" 

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

311 offset += xsize * ysize 

312 

313 elif compression == 1: 

314 # 

315 # packbits compression 

316 i = 0 

317 bytecount = ImageFile._safe_read(file, channels * ysize * 2) 

318 offset = file.tell() 

319 for channel in range(channels): 

320 layer = mode[channel] 

321 if mode == "CMYK": 

322 layer += ";I" 

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

324 for y in range(ysize): 

325 offset += i16(bytecount, i) 

326 i += 2 

327 

328 file.seek(offset) 

329 

330 if offset & 1: 

331 file.read(1) # padding 

332 

333 return tiles 

334 

335 

336# -------------------------------------------------------------------- 

337# registry 

338 

339 

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

341 

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

343 

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