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

1# 

2# The Python Imaging Library. 

3# $Id$ 

4# 

5# BMP file handler 

6# 

7# Windows (and OS/2) native bitmap storage format. 

8# 

9# history: 

10# 1995-09-01 fl Created 

11# 1996-04-30 fl Added save 

12# 1997-08-27 fl Fixed save of 1-bit images 

13# 1998-03-06 fl Load P images as L where possible 

14# 1998-07-03 fl Load P images as 1 where possible 

15# 1998-12-29 fl Handle small palettes 

16# 2002-12-30 fl Fixed load of 1-bit palette images 

17# 2003-04-21 fl Fixed load of 1-bit monochrome images 

18# 2003-04-23 fl Added limited support for BI_BITFIELDS compression 

19# 

20# Copyright (c) 1997-2003 by Secret Labs AB 

21# Copyright (c) 1995-2003 by Fredrik Lundh 

22# 

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

24# 

25from __future__ import annotations 

26 

27import os 

28from typing import IO, Any 

29 

30from . import Image, ImageFile, ImagePalette 

31from ._binary import i16le as i16 

32from ._binary import i32le as i32 

33from ._binary import o8 

34from ._binary import o16le as o16 

35from ._binary import o32le as o32 

36 

37# 

38# -------------------------------------------------------------------- 

39# Read BMP file 

40 

41BIT2MODE = { 

42 # bits => mode, rawmode 

43 1: ("P", "P;1"), 

44 4: ("P", "P;4"), 

45 8: ("P", "P"), 

46 16: ("RGB", "BGR;15"), 

47 24: ("RGB", "BGR"), 

48 32: ("RGB", "BGRX"), 

49} 

50 

51USE_RAW_ALPHA = False 

52 

53 

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

55 return prefix.startswith(b"BM") 

56 

57 

58def _dib_accept(prefix: bytes) -> bool: 

59 return i32(prefix) in [12, 40, 52, 56, 64, 108, 124] 

60 

61 

62# ============================================================================= 

63# Image plugin for the Windows BMP format. 

64# ============================================================================= 

65class BmpImageFile(ImageFile.ImageFile): 

66 """Image plugin for the Windows Bitmap format (BMP)""" 

67 

68 # ------------------------------------------------------------- Description 

69 format_description = "Windows Bitmap" 

70 format = "BMP" 

71 

72 # -------------------------------------------------- BMP Compression values 

73 COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5} 

74 for k, v in COMPRESSIONS.items(): 

75 vars()[k] = v 

76 

77 def _bitmap(self, header: int = 0, offset: int = 0) -> None: 

78 """Read relevant info about the BMP""" 

79 assert self.fp is not None 

80 read, seek = self.fp.read, self.fp.seek 

81 if header: 

82 seek(header) 

83 # read bmp header size @offset 14 (this is part of the header size) 

84 file_info: dict[str, bool | int | tuple[int, ...]] = { 

85 "header_size": i32(read(4)), 

86 "direction": -1, 

87 } 

88 

89 # -------------------- If requested, read header at a specific position 

90 # read the rest of the bmp header, without its size 

91 assert isinstance(file_info["header_size"], int) 

92 header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4) 

93 

94 # ------------------------------- Windows Bitmap v2, IBM OS/2 Bitmap v1 

95 # ----- This format has different offsets because of width/height types 

96 # 12: BITMAPCOREHEADER/OS21XBITMAPHEADER 

97 if file_info["header_size"] == 12: 

98 file_info["width"] = i16(header_data, 0) 

99 file_info["height"] = i16(header_data, 2) 

100 file_info["planes"] = i16(header_data, 4) 

101 file_info["bits"] = i16(header_data, 6) 

102 file_info["compression"] = self.COMPRESSIONS["RAW"] 

103 file_info["palette_padding"] = 3 

104 

105 # --------------------------------------------- Windows Bitmap v3 to v5 

106 # 40: BITMAPINFOHEADER 

107 # 52: BITMAPV2HEADER 

108 # 56: BITMAPV3HEADER 

109 # 64: BITMAPCOREHEADER2/OS22XBITMAPHEADER 

110 # 108: BITMAPV4HEADER 

111 # 124: BITMAPV5HEADER 

112 elif file_info["header_size"] in (40, 52, 56, 64, 108, 124): 

113 file_info["y_flip"] = header_data[7] == 0xFF 

114 file_info["direction"] = 1 if file_info["y_flip"] else -1 

115 file_info["width"] = i32(header_data, 0) 

116 file_info["height"] = ( 

117 i32(header_data, 4) 

118 if not file_info["y_flip"] 

119 else 2**32 - i32(header_data, 4) 

120 ) 

121 file_info["planes"] = i16(header_data, 8) 

122 file_info["bits"] = i16(header_data, 10) 

123 file_info["compression"] = i32(header_data, 12) 

124 # byte size of pixel data 

125 file_info["data_size"] = i32(header_data, 16) 

126 file_info["pixels_per_meter"] = ( 

127 i32(header_data, 20), 

128 i32(header_data, 24), 

129 ) 

130 file_info["colors"] = i32(header_data, 28) 

131 file_info["palette_padding"] = 4 

132 assert isinstance(file_info["pixels_per_meter"], tuple) 

133 self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"]) 

134 if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]: 

135 masks = ["r_mask", "g_mask", "b_mask"] 

136 if len(header_data) >= 48: 

137 if len(header_data) >= 52: 

138 masks.append("a_mask") 

139 else: 

140 file_info["a_mask"] = 0x0 

141 for idx, mask in enumerate(masks): 

142 file_info[mask] = i32(header_data, 36 + idx * 4) 

143 else: 

144 # 40 byte headers only have the three components in the 

145 # bitfields masks, ref: 

146 # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx 

147 # See also 

148 # https://github.com/python-pillow/Pillow/issues/1293 

149 # There is a 4th component in the RGBQuad, in the alpha 

150 # location, but it is listed as a reserved component, 

151 # and it is not generally an alpha channel 

152 file_info["a_mask"] = 0x0 

153 for mask in masks: 

154 file_info[mask] = i32(read(4)) 

155 assert isinstance(file_info["r_mask"], int) 

156 assert isinstance(file_info["g_mask"], int) 

157 assert isinstance(file_info["b_mask"], int) 

158 assert isinstance(file_info["a_mask"], int) 

159 file_info["rgb_mask"] = ( 

160 file_info["r_mask"], 

161 file_info["g_mask"], 

162 file_info["b_mask"], 

163 ) 

164 file_info["rgba_mask"] = ( 

165 file_info["r_mask"], 

166 file_info["g_mask"], 

167 file_info["b_mask"], 

168 file_info["a_mask"], 

169 ) 

170 else: 

171 msg = f"Unsupported BMP header type ({file_info['header_size']})" 

172 raise OSError(msg) 

173 

174 # ------------------ Special case : header is reported 40, which 

175 # ---------------------- is shorter than real size for bpp >= 16 

176 assert isinstance(file_info["width"], int) 

177 assert isinstance(file_info["height"], int) 

178 self._size = file_info["width"], file_info["height"] 

179 

180 # ------- If color count was not found in the header, compute from bits 

181 assert isinstance(file_info["bits"], int) 

182 if not file_info.get("colors", 0): 

183 file_info["colors"] = 1 << file_info["bits"] 

184 assert isinstance(file_info["palette_padding"], int) 

185 assert isinstance(file_info["colors"], int) 

186 if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8: 

187 offset += file_info["palette_padding"] * file_info["colors"] 

188 

189 # ---------------------- Check bit depth for unusual unsupported values 

190 self._mode, raw_mode = BIT2MODE.get(file_info["bits"], ("", "")) 

191 if not self.mode: 

192 msg = f"Unsupported BMP pixel depth ({file_info['bits']})" 

193 raise OSError(msg) 

194 

195 # ---------------- Process BMP with Bitfields compression (not palette) 

196 decoder_name = "raw" 

197 if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]: 

198 SUPPORTED: dict[int, list[tuple[int, ...]]] = { 

199 32: [ 

200 (0xFF0000, 0xFF00, 0xFF, 0x0), 

201 (0xFF000000, 0xFF0000, 0xFF00, 0x0), 

202 (0xFF000000, 0xFF00, 0xFF, 0x0), 

203 (0xFF000000, 0xFF0000, 0xFF00, 0xFF), 

204 (0xFF, 0xFF00, 0xFF0000, 0xFF000000), 

205 (0xFF0000, 0xFF00, 0xFF, 0xFF000000), 

206 (0xFF000000, 0xFF00, 0xFF, 0xFF0000), 

207 (0x0, 0x0, 0x0, 0x0), 

208 ], 

209 24: [(0xFF0000, 0xFF00, 0xFF)], 

210 16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)], 

211 } 

212 MASK_MODES = { 

213 (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX", 

214 (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR", 

215 (32, (0xFF000000, 0xFF00, 0xFF, 0x0)): "BGXR", 

216 (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR", 

217 (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA", 

218 (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA", 

219 (32, (0xFF000000, 0xFF00, 0xFF, 0xFF0000)): "BGAR", 

220 (32, (0x0, 0x0, 0x0, 0x0)): "BGRA", 

221 (24, (0xFF0000, 0xFF00, 0xFF)): "BGR", 

222 (16, (0xF800, 0x7E0, 0x1F)): "BGR;16", 

223 (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15", 

224 } 

225 if file_info["bits"] in SUPPORTED: 

226 if ( 

227 file_info["bits"] == 32 

228 and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]] 

229 ): 

230 assert isinstance(file_info["rgba_mask"], tuple) 

231 raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])] 

232 self._mode = "RGBA" if "A" in raw_mode else self.mode 

233 elif ( 

234 file_info["bits"] in (24, 16) 

235 and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]] 

236 ): 

237 assert isinstance(file_info["rgb_mask"], tuple) 

238 raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])] 

239 else: 

240 msg = "Unsupported BMP bitfields layout" 

241 raise OSError(msg) 

242 else: 

243 msg = "Unsupported BMP bitfields layout" 

244 raise OSError(msg) 

245 elif file_info["compression"] == self.COMPRESSIONS["RAW"]: 

246 if file_info["bits"] == 32 and ( 

247 header == 22 or USE_RAW_ALPHA # 32-bit .cur offset 

248 ): 

249 raw_mode, self._mode = "BGRA", "RGBA" 

250 elif file_info["compression"] in ( 

251 self.COMPRESSIONS["RLE8"], 

252 self.COMPRESSIONS["RLE4"], 

253 ): 

254 decoder_name = "bmp_rle" 

255 else: 

256 msg = f"Unsupported BMP compression ({file_info['compression']})" 

257 raise OSError(msg) 

258 

259 # --------------- Once the header is processed, process the palette/LUT 

260 if self.mode == "P": # Paletted for 1, 4 and 8 bit images 

261 # ---------------------------------------------------- 1-bit images 

262 if not (0 < file_info["colors"] <= 65536): 

263 msg = f"Unsupported BMP Palette size ({file_info['colors']})" 

264 raise OSError(msg) 

265 else: 

266 padding = file_info["palette_padding"] 

267 palette = read(padding * file_info["colors"]) 

268 grayscale = True 

269 indices = ( 

270 (0, 255) 

271 if file_info["colors"] == 2 

272 else list(range(file_info["colors"])) 

273 ) 

274 

275 # ----------------- Check if grayscale and ignore palette if so 

276 for ind, val in enumerate(indices): 

277 rgb = palette[ind * padding : ind * padding + 3] 

278 if rgb != o8(val) * 3: 

279 grayscale = False 

280 

281 # ------- If all colors are gray, white or black, ditch palette 

282 if grayscale: 

283 self._mode = "1" if file_info["colors"] == 2 else "L" 

284 raw_mode = self.mode 

285 else: 

286 self._mode = "P" 

287 self.palette = ImagePalette.raw( 

288 "BGRX" if padding == 4 else "BGR", palette 

289 ) 

290 

291 # ---------------------------- Finally set the tile data for the plugin 

292 self.info["compression"] = file_info["compression"] 

293 args: list[Any] = [raw_mode] 

294 if decoder_name == "bmp_rle": 

295 args.append(file_info["compression"] == self.COMPRESSIONS["RLE4"]) 

296 else: 

297 assert isinstance(file_info["width"], int) 

298 args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3)) 

299 args.append(file_info["direction"]) 

300 self.tile = [ 

301 ImageFile._Tile( 

302 decoder_name, 

303 (0, 0, file_info["width"], file_info["height"]), 

304 offset or self.fp.tell(), 

305 tuple(args), 

306 ) 

307 ] 

308 

309 def _open(self) -> None: 

310 """Open file, check magic number and read header""" 

311 # read 14 bytes: magic number, filesize, reserved, header final offset 

312 assert self.fp is not None 

313 head_data = self.fp.read(14) 

314 # choke if the file does not have the required magic bytes 

315 if not _accept(head_data): 

316 msg = "Not a BMP file" 

317 raise SyntaxError(msg) 

318 # read the start position of the BMP image data (u32) 

319 offset = i32(head_data, 10) 

320 # load bitmap information (offset=raster info) 

321 self._bitmap(offset=offset) 

322 

323 

324class BmpRleDecoder(ImageFile.PyDecoder): 

325 _pulls_fd = True 

326 

327 def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]: 

328 assert self.fd is not None 

329 rle4 = self.args[1] 

330 data = bytearray() 

331 x = 0 

332 dest_length = self.state.xsize * self.state.ysize 

333 while len(data) < dest_length: 

334 pixels = self.fd.read(1) 

335 byte = self.fd.read(1) 

336 if not pixels or not byte: 

337 break 

338 num_pixels = pixels[0] 

339 if num_pixels: 

340 # encoded mode 

341 if x + num_pixels > self.state.xsize: 

342 # Too much data for row 

343 num_pixels = max(0, self.state.xsize - x) 

344 if rle4: 

345 first_pixel = o8(byte[0] >> 4) 

346 second_pixel = o8(byte[0] & 0x0F) 

347 for index in range(num_pixels): 

348 if index % 2 == 0: 

349 data += first_pixel 

350 else: 

351 data += second_pixel 

352 else: 

353 data += byte * num_pixels 

354 x += num_pixels 

355 else: 

356 if byte[0] == 0: 

357 # end of line 

358 while len(data) % self.state.xsize != 0: 

359 data += b"\x00" 

360 x = 0 

361 elif byte[0] == 1: 

362 # end of bitmap 

363 break 

364 elif byte[0] == 2: 

365 # delta 

366 bytes_read = self.fd.read(2) 

367 if len(bytes_read) < 2: 

368 break 

369 right, up = bytes_read 

370 data += b"\x00" * (right + up * self.state.xsize) 

371 x = len(data) % self.state.xsize 

372 else: 

373 # absolute mode 

374 if rle4: 

375 # 2 pixels per byte 

376 byte_count = byte[0] // 2 

377 bytes_read = self.fd.read(byte_count) 

378 for byte_read in bytes_read: 

379 data += o8(byte_read >> 4) 

380 data += o8(byte_read & 0x0F) 

381 else: 

382 byte_count = byte[0] 

383 bytes_read = self.fd.read(byte_count) 

384 data += bytes_read 

385 if len(bytes_read) < byte_count: 

386 break 

387 x += byte[0] 

388 

389 # align to 16-bit word boundary 

390 if self.fd.tell() % 2 != 0: 

391 self.fd.seek(1, os.SEEK_CUR) 

392 rawmode = "L" if self.mode == "L" else "P" 

393 self.set_as_raw(bytes(data), rawmode, (0, self.args[-1])) 

394 return -1, 0 

395 

396 

397# ============================================================================= 

398# Image plugin for the DIB format (BMP alias) 

399# ============================================================================= 

400class DibImageFile(BmpImageFile): 

401 format = "DIB" 

402 format_description = "Windows Bitmap" 

403 

404 def _open(self) -> None: 

405 self._bitmap() 

406 

407 

408# 

409# -------------------------------------------------------------------- 

410# Write BMP file 

411 

412 

413SAVE = { 

414 "1": ("1", 1, 2), 

415 "L": ("L", 8, 256), 

416 "P": ("P", 8, 256), 

417 "RGB": ("BGR", 24, 0), 

418 "RGBA": ("BGRA", 32, 0), 

419} 

420 

421 

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

423 _save(im, fp, filename, False) 

424 

425 

426def _save( 

427 im: Image.Image, fp: IO[bytes], filename: str | bytes, bitmap_header: bool = True 

428) -> None: 

429 try: 

430 rawmode, bits, colors = SAVE[im.mode] 

431 except KeyError as e: 

432 msg = f"cannot write mode {im.mode} as BMP" 

433 raise OSError(msg) from e 

434 

435 info = im.encoderinfo 

436 

437 dpi = info.get("dpi", (96, 96)) 

438 

439 # 1 meter == 39.3701 inches 

440 ppm = tuple(int(x * 39.3701 + 0.5) for x in dpi) 

441 

442 stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3) 

443 header = 40 # or 64 for OS/2 version 2 

444 image = stride * im.size[1] 

445 

446 if im.mode == "1": 

447 palette = b"".join(o8(i) * 3 + b"\x00" for i in (0, 255)) 

448 elif im.mode == "L": 

449 palette = b"".join(o8(i) * 3 + b"\x00" for i in range(256)) 

450 elif im.mode == "P": 

451 palette = im.im.getpalette("RGB", "BGRX") 

452 colors = len(palette) // 4 

453 else: 

454 palette = None 

455 

456 # bitmap header 

457 if bitmap_header: 

458 offset = 14 + header + colors * 4 

459 file_size = offset + image 

460 if file_size > 2**32 - 1: 

461 msg = "File size is too large for the BMP format" 

462 raise ValueError(msg) 

463 fp.write( 

464 b"BM" # file type (magic) 

465 + o32(file_size) # file size 

466 + o32(0) # reserved 

467 + o32(offset) # image data offset 

468 ) 

469 

470 # bitmap info header 

471 fp.write( 

472 o32(header) # info header size 

473 + o32(im.size[0]) # width 

474 + o32(im.size[1]) # height 

475 + o16(1) # planes 

476 + o16(bits) # depth 

477 + o32(0) # compression (0=uncompressed) 

478 + o32(image) # size of bitmap 

479 + o32(ppm[0]) # resolution 

480 + o32(ppm[1]) # resolution 

481 + o32(colors) # colors used 

482 + o32(colors) # colors important 

483 ) 

484 

485 fp.write(b"\0" * (header - 40)) # padding (for OS/2 format) 

486 

487 if palette: 

488 fp.write(palette) 

489 

490 ImageFile._save( 

491 im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))] 

492 ) 

493 

494 

495# 

496# -------------------------------------------------------------------- 

497# Registry 

498 

499 

500Image.register_open(BmpImageFile.format, BmpImageFile, _accept) 

501Image.register_save(BmpImageFile.format, _save) 

502 

503Image.register_extension(BmpImageFile.format, ".bmp") 

504 

505Image.register_mime(BmpImageFile.format, "image/bmp") 

506 

507Image.register_decoder("bmp_rle", BmpRleDecoder) 

508 

509Image.register_open(DibImageFile.format, DibImageFile, _dib_accept) 

510Image.register_save(DibImageFile.format, _dib_save) 

511 

512Image.register_extension(DibImageFile.format, ".dib") 

513 

514Image.register_mime(DibImageFile.format, "image/bmp")