| ent"] = s | |
| self.app["COM"] = s # compatibility | |
| self.applist.append(("COM", s)) | |
| def SOF(self, marker): | |
| # | |
| # Start of frame marker. Defines the size and mode of the | |
| # image. JPEG is colour blind, so we use some simple | |
| # heuristics to map the number of layers to an appropriate | |
| # mode. Note that this could be made a bit brighter, by | |
| # looking for JFIF and Adobe APP markers. | |
| n = i16(self.fp.read(2)) - 2 | |
| s = ImageFile._safe_read(self.fp, n) | |
| self._size = i16(s, 3), i16(s, 1) | |
| self.bits = s[0] | |
| if self.bits != 8: | |
| msg = f"cannot handle {self.bits}-bit layers" | |
| raise SyntaxError(msg) | |
| self.layers = s[5] | |
| if self.layers == 1: | |
| self._mode = "L" | |
| elif self.layers == 3: | |
| self._mode = "RGB" | |
| elif self.layers == 4: | |
| self._mode = "CMYK" | |
| else: | |
| msg = f"cannot handle {self.layers}-layer images" | |
| raise SyntaxError(msg) | |
| if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]: | |
| self.info["progressive"] = self.info["progression"] = 1 | |
| if self.icclist: | |
| # fixup icc profile | |
| self.icclist.sort() # sort by sequence number | |
| if self.icclist[0][13] == len(self.icclist): | |
| profile = [] | |
| for p in self.icclist: | |
| profile.append(p[14:]) | |
| icc_profile = b"".join(profile) | |
| else: | |
| icc_profile = None # wrong number of fragments | |
| self.info["icc_profile"] = icc_profile | |
| self.icclist = [] | |
| for i in range(6, len(s), 3): | |
| t = s[i : i + 3] | |
| # 4-tuples: id, vsamp, hsamp, qtable | |
| self.layer.append((t[0], t[1] // 16, t[1] & 15, t[2])) | |
| def DQT(self, marker): | |
| # | |
| # Define quantization table. Note that there might be more | |
| # than one table in each marker. | |
| # FIXME: The quantization tables can be used to estimate the | |
| # compression quality. | |
| n = i16(self.fp.read(2)) - 2 | |
| s = ImageFile._safe_read(self.fp, n) | |
| while len(s): | |
| v = s[0] | |
| precision = 1 if (v // 16 == 0) else 2 # in bytes | |
| qt_length = 1 + precision * 64 | |
| if len(s) < qt_length: | |
| msg = "bad quantization table marker" | |
| raise SyntaxError(msg) | |
| data = array.array("B" if precision == 1 else "H", s[1:qt_length]) | |
| if sys.byteorder == "little" and precision > 1: | |
| data.byteswap() # the values are always big-endian | |
| self.quantization[v & 15] = [data[i] for i in zigzag_index] | |
| s = s[qt_length:] | |
| # | |
| # JPEG marker table | |
| MARKER = { | |
| 0xFFC0: ("SOF0", "Baseline DCT", SOF), | |
| 0xFFC1: ("SOF1", "Extended Sequential DCT", SOF), | |
| 0xFFC2: ("SOF2", "Progressive DCT", SOF), | |
| 0xFFC3: ("SOF3", "Spatial lossless", SOF), | |
| 0xFFC4: ("DHT", "Define Huffman table", Skip), | |
| 0xFFC5: ("SOF5", "Differential sequential DCT", SOF), | |
| 0xFFC6: ("SOF6", "Differential progressive DCT", SOF), | |
| 0xFFC7: ("SOF7", "Differential spatial", SOF), | |
| 0xFFC8: ("JPG", "Extension", None), | |
| 0xFFC9: ("SOF9", "Extended sequential DCT (AC)", SOF), | |
| 0xFFCA: ("SOF10", "Progressive DCT (AC)", SOF), | |
| 0xFFCB: ("SOF11", "Spatial lossless DCT (AC)", SOF), | |
| 0xFFCC: ("DAC", "Define arithmetic coding conditioning", Skip), | |
| 0xFFCD: ("SOF13", "Differential sequential DCT (AC)", SOF), | |
| 0xFFCE: ("SOF14", "Differential progressive DCT (AC)", SOF), | |
| 0xFFCF: ("SOF15", "Differential spatial (AC)", SOF), | |
| 0xFFD0: ("RST0", "Restart 0", None), | |
| 0xFFD1: ("RST1", "Restart 1", None), | |
| 0xFFD2: ("RST2", "Restart 2", None), | |
| 0xFFD3: ("RST3", "Restart 3", None), | |
| 0xFFD4: ("RST4", "Restart 4", None), | |
| 0xFFD5: ("RST5", "Restart 5", None), | |
| 0xFFD6: ("RST6", "Restart 6", None), | |
| 0xFFD7: ("RST7", "Restart 7", None), | |
| 0xFFD8: ("SOI", "Start of image", None), | |
| 0xFFD9: ("EOI", "End of image", None), | |
| 0xFFDA: ("SOS", "Start of scan", Skip), | |
| 0xFFDB: ("DQT", "Define quantization table", DQT), | |
| 0xFFDC: ("DNL", "Define number of lines", Skip), | |
| 0xFFDD: ("DRI", "Define restart interval", Skip), | |
| 0xFFDE: ("DHP", "Define hierarchical progression", SOF), | |
| 0xFFDF: ("EXP", "Expand reference component", Skip), | |
| 0xFFE0: ("APP0", "Application segment 0", APP), | |
| 0xFFE1: ("APP1", "Application segment 1", APP), | |
| 0xFFE2: ("APP2", "Application segment 2", APP), | |
| 0xFFE3: ("APP3", "Application segment 3", APP), | |
| 0xFFE4: ("APP4", "Application segment 4", APP), | |
| 0xFFE5: ("APP5", "Application segment 5", APP), | |
| 0xFFE6: ("APP6", "Application segment 6", APP), | |
| 0xFFE7: ("APP7", "Application segment 7", APP), | |
| 0xFFE8: ("APP8", "Application segment 8", APP), | |
| 0xFFE9: ("APP9", "Application segment 9", APP), | |
| 0xFFEA: ("APP10", "Application segment 10", APP), | |
| 0xFFEB: ("APP11", "Application segment 11", APP), | |
| 0xFFEC: ("APP12", "Application segment 12", APP), | |
| 0xFFED: ("APP13", "Application segment 13", APP), | |
| 0xFFEE: ("APP14", "Application segment 14", APP), | |
| 0xFFEF: ("APP15", "Application segment 15", APP), | |
| 0xFFF0: ("JPG0", "Extension 0", None), | |
| 0xFFF1: ("JPG1", "Extension 1", None), | |
| 0xFFF2: ("JPG2", "Extension 2", None), | |
| 0xFFF3: ("JPG3", "Extension 3", None), | |
| 0xFFF4: ("JPG4", "Extension 4", None), | |
| 0xFFF5: ("JPG5", "Extension 5", None), | |
| 0xFFF6: ("JPG6", "Extension 6", None), | |
| 0xFFF7: ("JPG7", "Extension 7", None), | |
| 0xFFF8: ("JPG8", "Extension 8", None), | |
| 0xFFF9: ("JPG9", "Extension 9", None), | |
| 0xFFFA: ("JPG10", "Extension 10", None), | |
| 0xFFFB: ("JPG11", "Extension 11", None), | |
| 0xFFFC: ("JPG12", "Extension 12", None), | |
| 0xFFFD: ("JPG13", "Extension 13", None), | |
| 0xFFFE: ("COM", "Comment", COM), | |
| } | |
| def _accept(prefix): | |
| # Magic number was taken from https://en.wikipedia.org/wiki/JPEG | |
| return prefix[:3] == b"\xFF\xD8\xFF" | |
| ## | |
| # Image plugin for JPEG and JFIF images. | |
| class JpegImageFile(ImageFile.ImageFile): | |
| format = "JPEG" | |
| format_description = "JPEG (ISO 10918)" | |
| def _open(self): | |
| s = self.fp.read(3) | |
| if not _accept(s): | |
| msg = "not a JPEG file" | |
| raise SyntaxError(msg) | |
| s = b"\xFF" | |
| # Create attributes | |
| self.bits = self.layers = 0 | |
| # JPEG specifics (internal) | |
| self.layer = [] | |
| self.huffman_dc = {} | |
| self.huffman_ac = {} | |
| self.quantization = {} | |
| self.app = {} # compatibility | |
| self.applist = [] | |
| self.icclist = [] | |
| while True: | |
| i = s[0] | |
| if i == 0xFF: | |
| s = s + self.fp.read(1) | |
| i = i16(s) | |
| else: | |
| # Skip non-0xFF junk | |
| s = self.fp.read(1) | |
| continue | |
| if i in MARKER: | |
| name, description, handler = MARKER[i] | |
| if handler is not None: | |
| handler(self, i) | |
| if i == 0xFFDA: # start of scan | |
| rawmode = self.mode | |
| if self.mode == "CMYK": | |
| rawmode = "CMYK;I" # assume adobe conventions | |
| self.tile = [("jpeg", (0, 0) + self.size, 0, (rawmode, ""))] | |
| # self.__offset = self.fp.tell() | |
| break | |
| s = self.fp.read(1) | |
| elif i == 0 or i == 0xFFFF: | |
| # padded marker or junk; move on | |
| s = b"\xff" | |
| elif i == 0xFF00: # Skip extraneous data (escaped 0xFF) | |
| s = self.fp.read(1) | |
| else: | |
| msg = "no marker found" | |
| raise SyntaxError(msg) | |
| def load_read(self, read_bytes): | |
| """ | |
| internal: read more image data | |
| For premature EOF and LOAD_TRUNCATED_IMAGES adds EOI marker | |
| so libjpeg can finish decoding | |
| """ | |
| s = self.fp.read(read_bytes) | |
| if not s and ImageFile.LOAD_TRUNCATED_IMAGES and not hasattr(self, "_ended"): | |
| # Premature EOF. | |
| # Pretend file is finished adding EOI marker | |
| self._ended = True | |
| return b"\xFF\xD9" | |
| return s | |
| def draft(self, mode, size): | |
| if len(self.tile) != 1: | |
| return | |
| # Protect from second call | |
| if self.decoderconfig: | |
| return | |
| d, e, o, a = self.tile[0] | |
| scale = 1 | |
| original_size = self.size | |
| if a[0] == "RGB" and mode in ["L", "YCbCr"]: | |
| self._mode = mode | |
| a = mode, "" | |
| if size: | |
| scale = min(self.size[0] // size[0], self.size[1] // size[1]) | |
| for s in [8, 4, 2, 1]: | |
| if scale >= s: | |
| break | |
| e = ( | |
| e[0], | |
| e[1], | |
| (e[2] - e[0] + s - 1) // s + e[0], | |
| (e[3] - e[1] + s - 1) // s + e[1], | |
| ) | |
| self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s) | |
| scale = s | |
| self.tile = [(d, e, o, a)] | |
| self.decoderconfig = (scale, 0) | |
| b |