| 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 |
