473 lines
17 KiB
Python
473 lines
17 KiB
Python
#
|
|
# The Python Imaging Library.
|
|
# $Id$
|
|
#
|
|
# BMP file handler
|
|
#
|
|
# Windows (and OS/2) native bitmap storage format.
|
|
#
|
|
# history:
|
|
# 1995-09-01 fl Created
|
|
# 1996-04-30 fl Added save
|
|
# 1997-08-27 fl Fixed save of 1-bit images
|
|
# 1998-03-06 fl Load P images as L where possible
|
|
# 1998-07-03 fl Load P images as 1 where possible
|
|
# 1998-12-29 fl Handle small palettes
|
|
# 2002-12-30 fl Fixed load of 1-bit palette images
|
|
# 2003-04-21 fl Fixed load of 1-bit monochrome images
|
|
# 2003-04-23 fl Added limited support for BI_BITFIELDS compression
|
|
#
|
|
# Copyright (c) 1997-2003 by Secret Labs AB
|
|
# Copyright (c) 1995-2003 by Fredrik Lundh
|
|
#
|
|
# See the README file for information on usage and redistribution.
|
|
#
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
|
|
from . import Image, ImageFile, ImagePalette
|
|
from ._binary import i16le as i16
|
|
from ._binary import i32le as i32
|
|
from ._binary import o8
|
|
from ._binary import o16le as o16
|
|
from ._binary import o32le as o32
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Read BMP file
|
|
|
|
BIT2MODE = {
|
|
# bits => mode, rawmode
|
|
1: ("P", "P;1"),
|
|
4: ("P", "P;4"),
|
|
8: ("P", "P"),
|
|
16: ("RGB", "BGR;15"),
|
|
24: ("RGB", "BGR"),
|
|
32: ("RGB", "BGRX"),
|
|
}
|
|
|
|
|
|
def _accept(prefix):
|
|
return prefix[:2] == b"BM"
|
|
|
|
|
|
def _dib_accept(prefix):
|
|
return i32(prefix) in [12, 40, 64, 108, 124]
|
|
|
|
|
|
# =============================================================================
|
|
# Image plugin for the Windows BMP format.
|
|
# =============================================================================
|
|
class BmpImageFile(ImageFile.ImageFile):
|
|
"""Image plugin for the Windows Bitmap format (BMP)"""
|
|
|
|
# ------------------------------------------------------------- Description
|
|
format_description = "Windows Bitmap"
|
|
format = "BMP"
|
|
|
|
# -------------------------------------------------- BMP Compression values
|
|
COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
|
|
for k, v in COMPRESSIONS.items():
|
|
vars()[k] = v
|
|
|
|
def _bitmap(self, header=0, offset=0):
|
|
"""Read relevant info about the BMP"""
|
|
read, seek = self.fp.read, self.fp.seek
|
|
if header:
|
|
seek(header)
|
|
# read bmp header size @offset 14 (this is part of the header size)
|
|
file_info = {"header_size": i32(read(4)), "direction": -1}
|
|
|
|
# -------------------- If requested, read header at a specific position
|
|
# read the rest of the bmp header, without its size
|
|
header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
|
|
|
|
# -------------------------------------------------- IBM OS/2 Bitmap v1
|
|
# ----- This format has different offsets because of width/height types
|
|
if file_info["header_size"] == 12:
|
|
file_info["width"] = i16(header_data, 0)
|
|
file_info["height"] = i16(header_data, 2)
|
|
file_info["planes"] = i16(header_data, 4)
|
|
file_info["bits"] = i16(header_data, 6)
|
|
file_info["compression"] = self.RAW
|
|
file_info["palette_padding"] = 3
|
|
|
|
# --------------------------------------------- Windows Bitmap v2 to v5
|
|
# v3, OS/2 v2, v4, v5
|
|
elif file_info["header_size"] in (40, 64, 108, 124):
|
|
file_info["y_flip"] = header_data[7] == 0xFF
|
|
file_info["direction"] = 1 if file_info["y_flip"] else -1
|
|
file_info["width"] = i32(header_data, 0)
|
|
file_info["height"] = (
|
|
i32(header_data, 4)
|
|
if not file_info["y_flip"]
|
|
else 2**32 - i32(header_data, 4)
|
|
)
|
|
file_info["planes"] = i16(header_data, 8)
|
|
file_info["bits"] = i16(header_data, 10)
|
|
file_info["compression"] = i32(header_data, 12)
|
|
# byte size of pixel data
|
|
file_info["data_size"] = i32(header_data, 16)
|
|
file_info["pixels_per_meter"] = (
|
|
i32(header_data, 20),
|
|
i32(header_data, 24),
|
|
)
|
|
file_info["colors"] = i32(header_data, 28)
|
|
file_info["palette_padding"] = 4
|
|
self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
|
|
if file_info["compression"] == self.BITFIELDS:
|
|
if len(header_data) >= 52:
|
|
for idx, mask in enumerate(
|
|
["r_mask", "g_mask", "b_mask", "a_mask"]
|
|
):
|
|
file_info[mask] = i32(header_data, 36 + idx * 4)
|
|
else:
|
|
# 40 byte headers only have the three components in the
|
|
# bitfields masks, ref:
|
|
# https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
|
|
# See also
|
|
# https://github.com/python-pillow/Pillow/issues/1293
|
|
# There is a 4th component in the RGBQuad, in the alpha
|
|
# location, but it is listed as a reserved component,
|
|
# and it is not generally an alpha channel
|
|
file_info["a_mask"] = 0x0
|
|
for mask in ["r_mask", "g_mask", "b_mask"]:
|
|
file_info[mask] = i32(read(4))
|
|
file_info["rgb_mask"] = (
|
|
file_info["r_mask"],
|
|
file_info["g_mask"],
|
|
file_info["b_mask"],
|
|
)
|
|
file_info["rgba_mask"] = (
|
|
file_info["r_mask"],
|
|
file_info["g_mask"],
|
|
file_info["b_mask"],
|
|
file_info["a_mask"],
|
|
)
|
|
else:
|
|
msg = f"Unsupported BMP header type ({file_info['header_size']})"
|
|
raise OSError(msg)
|
|
|
|
# ------------------ Special case : header is reported 40, which
|
|
# ---------------------- is shorter than real size for bpp >= 16
|
|
self._size = file_info["width"], file_info["height"]
|
|
|
|
# ------- If color count was not found in the header, compute from bits
|
|
file_info["colors"] = (
|
|
file_info["colors"]
|
|
if file_info.get("colors", 0)
|
|
else (1 << file_info["bits"])
|
|
)
|
|
if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
|
|
offset += 4 * file_info["colors"]
|
|
|
|
# ---------------------- Check bit depth for unusual unsupported values
|
|
self._mode, raw_mode = BIT2MODE.get(file_info["bits"], (None, None))
|
|
if self.mode is None:
|
|
msg = f"Unsupported BMP pixel depth ({file_info['bits']})"
|
|
raise OSError(msg)
|
|
|
|
# ---------------- Process BMP with Bitfields compression (not palette)
|
|
decoder_name = "raw"
|
|
if file_info["compression"] == self.BITFIELDS:
|
|
SUPPORTED = {
|
|
32: [
|
|
(0xFF0000, 0xFF00, 0xFF, 0x0),
|
|
(0xFF000000, 0xFF0000, 0xFF00, 0x0),
|
|
(0xFF000000, 0xFF0000, 0xFF00, 0xFF),
|
|
(0xFF, 0xFF00, 0xFF0000, 0xFF000000),
|
|
(0xFF0000, 0xFF00, 0xFF, 0xFF000000),
|
|
(0x0, 0x0, 0x0, 0x0),
|
|
],
|
|
24: [(0xFF0000, 0xFF00, 0xFF)],
|
|
16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
|
|
}
|
|
MASK_MODES = {
|
|
(32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
|
|
(32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
|
|
(32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
|
|
(32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
|
|
(32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
|
|
(32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
|
|
(24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
|
|
(16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
|
|
(16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
|
|
}
|
|
if file_info["bits"] in SUPPORTED:
|
|
if (
|
|
file_info["bits"] == 32
|
|
and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
|
|
):
|
|
raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
|
|
self._mode = "RGBA" if "A" in raw_mode else self.mode
|
|
elif (
|
|
file_info["bits"] in (24, 16)
|
|
and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
|
|
):
|
|
raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
|
|
else:
|
|
msg = "Unsupported BMP bitfields layout"
|
|
raise OSError(msg)
|
|
else:
|
|
msg = "Unsupported BMP bitfields layout"
|
|
raise OSError(msg)
|
|
elif file_info["compression"] == self.RAW:
|
|
if file_info["bits"] == 32 and header == 22: # 32-bit .cur offset
|
|
raw_mode, self._mode = "BGRA", "RGBA"
|
|
elif file_info["compression"] in (self.RLE8, self.RLE4):
|
|
decoder_name = "bmp_rle"
|
|
else:
|
|
msg = f"Unsupported BMP compression ({file_info['compression']})"
|
|
raise OSError(msg)
|
|
|
|
# --------------- Once the header is processed, process the palette/LUT
|
|
if self.mode == "P": # Paletted for 1, 4 and 8 bit images
|
|
# ---------------------------------------------------- 1-bit images
|
|
if not (0 < file_info["colors"] <= 65536):
|
|
msg = f"Unsupported BMP Palette size ({file_info['colors']})"
|
|
raise OSError(msg)
|
|
else:
|
|
padding = file_info["palette_padding"]
|
|
palette = read(padding * file_info["colors"])
|
|
grayscale = True
|
|
indices = (
|
|
(0, 255)
|
|
if file_info["colors"] == 2
|
|
else list(range(file_info["colors"]))
|
|
)
|
|
|
|
# ----------------- Check if grayscale and ignore palette if so
|
|
for ind, val in enumerate(indices):
|
|
rgb = palette[ind * padding : ind * padding + 3]
|
|
if rgb != o8(val) * 3:
|
|
grayscale = False
|
|
|
|
# ------- If all colors are gray, white or black, ditch palette
|
|
if grayscale:
|
|
self._mode = "1" if file_info["colors"] == 2 else "L"
|
|
raw_mode = self.mode
|
|
else:
|
|
self._mode = "P"
|
|
self.palette = ImagePalette.raw(
|
|
"BGRX" if padding == 4 else "BGR", palette
|
|
)
|
|
|
|
# ---------------------------- Finally set the tile data for the plugin
|
|
self.info["compression"] = file_info["compression"]
|
|
args = [raw_mode]
|
|
if decoder_name == "bmp_rle":
|
|
args.append(file_info["compression"] == self.RLE4)
|
|
else:
|
|
args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
|
|
args.append(file_info["direction"])
|
|
self.tile = [
|
|
(
|
|
decoder_name,
|
|
(0, 0, file_info["width"], file_info["height"]),
|
|
offset or self.fp.tell(),
|
|
tuple(args),
|
|
)
|
|
]
|
|
|
|
def _open(self):
|
|
"""Open file, check magic number and read header"""
|
|
# read 14 bytes: magic number, filesize, reserved, header final offset
|
|
head_data = self.fp.read(14)
|
|
# choke if the file does not have the required magic bytes
|
|
if not _accept(head_data):
|
|
msg = "Not a BMP file"
|
|
raise SyntaxError(msg)
|
|
# read the start position of the BMP image data (u32)
|
|
offset = i32(head_data, 10)
|
|
# load bitmap information (offset=raster info)
|
|
self._bitmap(offset=offset)
|
|
|
|
|
|
class BmpRleDecoder(ImageFile.PyDecoder):
|
|
_pulls_fd = True
|
|
|
|
def decode(self, buffer):
|
|
rle4 = self.args[1]
|
|
data = bytearray()
|
|
x = 0
|
|
dest_length = self.state.xsize * self.state.ysize
|
|
while len(data) < dest_length:
|
|
pixels = self.fd.read(1)
|
|
byte = self.fd.read(1)
|
|
if not pixels or not byte:
|
|
break
|
|
num_pixels = pixels[0]
|
|
if num_pixels:
|
|
# encoded mode
|
|
if x + num_pixels > self.state.xsize:
|
|
# Too much data for row
|
|
num_pixels = max(0, self.state.xsize - x)
|
|
if rle4:
|
|
first_pixel = o8(byte[0] >> 4)
|
|
second_pixel = o8(byte[0] & 0x0F)
|
|
for index in range(num_pixels):
|
|
if index % 2 == 0:
|
|
data += first_pixel
|
|
else:
|
|
data += second_pixel
|
|
else:
|
|
data += byte * num_pixels
|
|
x += num_pixels
|
|
else:
|
|
if byte[0] == 0:
|
|
# end of line
|
|
while len(data) % self.state.xsize != 0:
|
|
data += b"\x00"
|
|
x = 0
|
|
elif byte[0] == 1:
|
|
# end of bitmap
|
|
break
|
|
elif byte[0] == 2:
|
|
# delta
|
|
bytes_read = self.fd.read(2)
|
|
if len(bytes_read) < 2:
|
|
break
|
|
right, up = self.fd.read(2)
|
|
data += b"\x00" * (right + up * self.state.xsize)
|
|
x = len(data) % self.state.xsize
|
|
else:
|
|
# absolute mode
|
|
if rle4:
|
|
# 2 pixels per byte
|
|
byte_count = byte[0] // 2
|
|
bytes_read = self.fd.read(byte_count)
|
|
for byte_read in bytes_read:
|
|
data += o8(byte_read >> 4)
|
|
data += o8(byte_read & 0x0F)
|
|
else:
|
|
byte_count = byte[0]
|
|
bytes_read = self.fd.read(byte_count)
|
|
data += bytes_read
|
|
if len(bytes_read) < byte_count:
|
|
break
|
|
x += byte[0]
|
|
|
|
# align to 16-bit word boundary
|
|
if self.fd.tell() % 2 != 0:
|
|
self.fd.seek(1, os.SEEK_CUR)
|
|
rawmode = "L" if self.mode == "L" else "P"
|
|
self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
|
|
return -1, 0
|
|
|
|
|
|
# =============================================================================
|
|
# Image plugin for the DIB format (BMP alias)
|
|
# =============================================================================
|
|
class DibImageFile(BmpImageFile):
|
|
format = "DIB"
|
|
format_description = "Windows Bitmap"
|
|
|
|
def _open(self):
|
|
self._bitmap()
|
|
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Write BMP file
|
|
|
|
|
|
SAVE = {
|
|
"1": ("1", 1, 2),
|
|
"L": ("L", 8, 256),
|
|
"P": ("P", 8, 256),
|
|
"RGB": ("BGR", 24, 0),
|
|
"RGBA": ("BGRA", 32, 0),
|
|
}
|
|
|
|
|
|
def _dib_save(im, fp, filename):
|
|
_save(im, fp, filename, False)
|
|
|
|
|
|
def _save(im, fp, filename, bitmap_header=True):
|
|
try:
|
|
rawmode, bits, colors = SAVE[im.mode]
|
|
except KeyError as e:
|
|
msg = f"cannot write mode {im.mode} as BMP"
|
|
raise OSError(msg) from e
|
|
|
|
info = im.encoderinfo
|
|
|
|
dpi = info.get("dpi", (96, 96))
|
|
|
|
# 1 meter == 39.3701 inches
|
|
ppm = tuple(int(x * 39.3701 + 0.5) for x in dpi)
|
|
|
|
stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
|
|
header = 40 # or 64 for OS/2 version 2
|
|
image = stride * im.size[1]
|
|
|
|
if im.mode == "1":
|
|
palette = b"".join(o8(i) * 4 for i in (0, 255))
|
|
elif im.mode == "L":
|
|
palette = b"".join(o8(i) * 4 for i in range(256))
|
|
elif im.mode == "P":
|
|
palette = im.im.getpalette("RGB", "BGRX")
|
|
colors = len(palette) // 4
|
|
else:
|
|
palette = None
|
|
|
|
# bitmap header
|
|
if bitmap_header:
|
|
offset = 14 + header + colors * 4
|
|
file_size = offset + image
|
|
if file_size > 2**32 - 1:
|
|
msg = "File size is too large for the BMP format"
|
|
raise ValueError(msg)
|
|
fp.write(
|
|
b"BM" # file type (magic)
|
|
+ o32(file_size) # file size
|
|
+ o32(0) # reserved
|
|
+ o32(offset) # image data offset
|
|
)
|
|
|
|
# bitmap info header
|
|
fp.write(
|
|
o32(header) # info header size
|
|
+ o32(im.size[0]) # width
|
|
+ o32(im.size[1]) # height
|
|
+ o16(1) # planes
|
|
+ o16(bits) # depth
|
|
+ o32(0) # compression (0=uncompressed)
|
|
+ o32(image) # size of bitmap
|
|
+ o32(ppm[0]) # resolution
|
|
+ o32(ppm[1]) # resolution
|
|
+ o32(colors) # colors used
|
|
+ o32(colors) # colors important
|
|
)
|
|
|
|
fp.write(b"\0" * (header - 40)) # padding (for OS/2 format)
|
|
|
|
if palette:
|
|
fp.write(palette)
|
|
|
|
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
|
|
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Registry
|
|
|
|
|
|
Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
|
|
Image.register_save(BmpImageFile.format, _save)
|
|
|
|
Image.register_extension(BmpImageFile.format, ".bmp")
|
|
|
|
Image.register_mime(BmpImageFile.format, "image/bmp")
|
|
|
|
Image.register_decoder("bmp_rle", BmpRleDecoder)
|
|
|
|
Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
|
|
Image.register_save(DibImageFile.format, _dib_save)
|
|
|
|
Image.register_extension(DibImageFile.format, ".dib")
|
|
|
|
Image.register_mime(DibImageFile.format, "image/bmp")
|