Spaces:
Running
Running
| # | |
| # 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") | |