Funktionierender Prototyp des Serious Games zur Vermittlung von Wissen zu Software-Engineering-Arbeitsmodellen.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

JpegImagePlugin.py 28KB

1 year ago
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850
  1. #
  2. # The Python Imaging Library.
  3. # $Id$
  4. #
  5. # JPEG (JFIF) file handling
  6. #
  7. # See "Digital Compression and Coding of Continuous-Tone Still Images,
  8. # Part 1, Requirements and Guidelines" (CCITT T.81 / ISO 10918-1)
  9. #
  10. # History:
  11. # 1995-09-09 fl Created
  12. # 1995-09-13 fl Added full parser
  13. # 1996-03-25 fl Added hack to use the IJG command line utilities
  14. # 1996-05-05 fl Workaround Photoshop 2.5 CMYK polarity bug
  15. # 1996-05-28 fl Added draft support, JFIF version (0.1)
  16. # 1996-12-30 fl Added encoder options, added progression property (0.2)
  17. # 1997-08-27 fl Save mode 1 images as BW (0.3)
  18. # 1998-07-12 fl Added YCbCr to draft and save methods (0.4)
  19. # 1998-10-19 fl Don't hang on files using 16-bit DQT's (0.4.1)
  20. # 2001-04-16 fl Extract DPI settings from JFIF files (0.4.2)
  21. # 2002-07-01 fl Skip pad bytes before markers; identify Exif files (0.4.3)
  22. # 2003-04-25 fl Added experimental EXIF decoder (0.5)
  23. # 2003-06-06 fl Added experimental EXIF GPSinfo decoder
  24. # 2003-09-13 fl Extract COM markers
  25. # 2009-09-06 fl Added icc_profile support (from Florian Hoech)
  26. # 2009-03-06 fl Changed CMYK handling; always use Adobe polarity (0.6)
  27. # 2009-03-08 fl Added subsampling support (from Justin Huff).
  28. #
  29. # Copyright (c) 1997-2003 by Secret Labs AB.
  30. # Copyright (c) 1995-1996 by Fredrik Lundh.
  31. #
  32. # See the README file for information on usage and redistribution.
  33. #
  34. import array
  35. import io
  36. import math
  37. import os
  38. import struct
  39. import subprocess
  40. import sys
  41. import tempfile
  42. import warnings
  43. from . import Image, ImageFile
  44. from ._binary import i16be as i16
  45. from ._binary import i32be as i32
  46. from ._binary import o8
  47. from ._binary import o16be as o16
  48. from ._deprecate import deprecate
  49. from .JpegPresets import presets
  50. #
  51. # Parser
  52. def Skip(self, marker):
  53. n = i16(self.fp.read(2)) - 2
  54. ImageFile._safe_read(self.fp, n)
  55. def APP(self, marker):
  56. #
  57. # Application marker. Store these in the APP dictionary.
  58. # Also look for well-known application markers.
  59. n = i16(self.fp.read(2)) - 2
  60. s = ImageFile._safe_read(self.fp, n)
  61. app = "APP%d" % (marker & 15)
  62. self.app[app] = s # compatibility
  63. self.applist.append((app, s))
  64. if marker == 0xFFE0 and s[:4] == b"JFIF":
  65. # extract JFIF information
  66. self.info["jfif"] = version = i16(s, 5) # version
  67. self.info["jfif_version"] = divmod(version, 256)
  68. # extract JFIF properties
  69. try:
  70. jfif_unit = s[7]
  71. jfif_density = i16(s, 8), i16(s, 10)
  72. except Exception:
  73. pass
  74. else:
  75. if jfif_unit == 1:
  76. self.info["dpi"] = jfif_density
  77. self.info["jfif_unit"] = jfif_unit
  78. self.info["jfif_density"] = jfif_density
  79. elif marker == 0xFFE1 and s[:5] == b"Exif\0":
  80. if "exif" not in self.info:
  81. # extract EXIF information (incomplete)
  82. self.info["exif"] = s # FIXME: value will change
  83. self._exif_offset = self.fp.tell() - n + 6
  84. elif marker == 0xFFE2 and s[:5] == b"FPXR\0":
  85. # extract FlashPix information (incomplete)
  86. self.info["flashpix"] = s # FIXME: value will change
  87. elif marker == 0xFFE2 and s[:12] == b"ICC_PROFILE\0":
  88. # Since an ICC profile can be larger than the maximum size of
  89. # a JPEG marker (64K), we need provisions to split it into
  90. # multiple markers. The format defined by the ICC specifies
  91. # one or more APP2 markers containing the following data:
  92. # Identifying string ASCII "ICC_PROFILE\0" (12 bytes)
  93. # Marker sequence number 1, 2, etc (1 byte)
  94. # Number of markers Total of APP2's used (1 byte)
  95. # Profile data (remainder of APP2 data)
  96. # Decoders should use the marker sequence numbers to
  97. # reassemble the profile, rather than assuming that the APP2
  98. # markers appear in the correct sequence.
  99. self.icclist.append(s)
  100. elif marker == 0xFFED and s[:14] == b"Photoshop 3.0\x00":
  101. # parse the image resource block
  102. offset = 14
  103. photoshop = self.info.setdefault("photoshop", {})
  104. while s[offset : offset + 4] == b"8BIM":
  105. try:
  106. offset += 4
  107. # resource code
  108. code = i16(s, offset)
  109. offset += 2
  110. # resource name (usually empty)
  111. name_len = s[offset]
  112. # name = s[offset+1:offset+1+name_len]
  113. offset += 1 + name_len
  114. offset += offset & 1 # align
  115. # resource data block
  116. size = i32(s, offset)
  117. offset += 4
  118. data = s[offset : offset + size]
  119. if code == 0x03ED: # ResolutionInfo
  120. data = {
  121. "XResolution": i32(data, 0) / 65536,
  122. "DisplayedUnitsX": i16(data, 4),
  123. "YResolution": i32(data, 8) / 65536,
  124. "DisplayedUnitsY": i16(data, 12),
  125. }
  126. photoshop[code] = data
  127. offset += size
  128. offset += offset & 1 # align
  129. except struct.error:
  130. break # insufficient data
  131. elif marker == 0xFFEE and s[:5] == b"Adobe":
  132. self.info["adobe"] = i16(s, 5)
  133. # extract Adobe custom properties
  134. try:
  135. adobe_transform = s[11]
  136. except IndexError:
  137. pass
  138. else:
  139. self.info["adobe_transform"] = adobe_transform
  140. elif marker == 0xFFE2 and s[:4] == b"MPF\0":
  141. # extract MPO information
  142. self.info["mp"] = s[4:]
  143. # offset is current location minus buffer size
  144. # plus constant header size
  145. self.info["mpoffset"] = self.fp.tell() - n + 4
  146. # If DPI isn't in JPEG header, fetch from EXIF
  147. if "dpi" not in self.info and "exif" in self.info:
  148. try:
  149. exif = self.getexif()
  150. resolution_unit = exif[0x0128]
  151. x_resolution = exif[0x011A]
  152. try:
  153. dpi = float(x_resolution[0]) / x_resolution[1]
  154. except TypeError:
  155. dpi = x_resolution
  156. if math.isnan(dpi):
  157. raise ValueError
  158. if resolution_unit == 3: # cm
  159. # 1 dpcm = 2.54 dpi
  160. dpi *= 2.54
  161. self.info["dpi"] = dpi, dpi
  162. except (TypeError, KeyError, SyntaxError, ValueError, ZeroDivisionError):
  163. # SyntaxError for invalid/unreadable EXIF
  164. # KeyError for dpi not included
  165. # ZeroDivisionError for invalid dpi rational value
  166. # ValueError or TypeError for dpi being an invalid float
  167. self.info["dpi"] = 72, 72
  168. def COM(self, marker):
  169. #
  170. # Comment marker. Store these in the APP dictionary.
  171. n = i16(self.fp.read(2)) - 2
  172. s = ImageFile._safe_read(self.fp, n)
  173. self.info["comment"] = s
  174. self.app["COM"] = s # compatibility
  175. self.applist.append(("COM", s))
  176. def SOF(self, marker):
  177. #
  178. # Start of frame marker. Defines the size and mode of the
  179. # image. JPEG is colour blind, so we use some simple
  180. # heuristics to map the number of layers to an appropriate
  181. # mode. Note that this could be made a bit brighter, by
  182. # looking for JFIF and Adobe APP markers.
  183. n = i16(self.fp.read(2)) - 2
  184. s = ImageFile._safe_read(self.fp, n)
  185. self._size = i16(s, 3), i16(s, 1)
  186. self.bits = s[0]
  187. if self.bits != 8:
  188. msg = f"cannot handle {self.bits}-bit layers"
  189. raise SyntaxError(msg)
  190. self.layers = s[5]
  191. if self.layers == 1:
  192. self.mode = "L"
  193. elif self.layers == 3:
  194. self.mode = "RGB"
  195. elif self.layers == 4:
  196. self.mode = "CMYK"
  197. else:
  198. msg = f"cannot handle {self.layers}-layer images"
  199. raise SyntaxError(msg)
  200. if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]:
  201. self.info["progressive"] = self.info["progression"] = 1
  202. if self.icclist:
  203. # fixup icc profile
  204. self.icclist.sort() # sort by sequence number
  205. if self.icclist[0][13] == len(self.icclist):
  206. profile = []
  207. for p in self.icclist:
  208. profile.append(p[14:])
  209. icc_profile = b"".join(profile)
  210. else:
  211. icc_profile = None # wrong number of fragments
  212. self.info["icc_profile"] = icc_profile
  213. self.icclist = []
  214. for i in range(6, len(s), 3):
  215. t = s[i : i + 3]
  216. # 4-tuples: id, vsamp, hsamp, qtable
  217. self.layer.append((t[0], t[1] // 16, t[1] & 15, t[2]))
  218. def DQT(self, marker):
  219. #
  220. # Define quantization table. Note that there might be more
  221. # than one table in each marker.
  222. # FIXME: The quantization tables can be used to estimate the
  223. # compression quality.
  224. n = i16(self.fp.read(2)) - 2
  225. s = ImageFile._safe_read(self.fp, n)
  226. while len(s):
  227. v = s[0]
  228. precision = 1 if (v // 16 == 0) else 2 # in bytes
  229. qt_length = 1 + precision * 64
  230. if len(s) < qt_length:
  231. msg = "bad quantization table marker"
  232. raise SyntaxError(msg)
  233. data = array.array("B" if precision == 1 else "H", s[1:qt_length])
  234. if sys.byteorder == "little" and precision > 1:
  235. data.byteswap() # the values are always big-endian
  236. self.quantization[v & 15] = [data[i] for i in zigzag_index]
  237. s = s[qt_length:]
  238. #
  239. # JPEG marker table
  240. MARKER = {
  241. 0xFFC0: ("SOF0", "Baseline DCT", SOF),
  242. 0xFFC1: ("SOF1", "Extended Sequential DCT", SOF),
  243. 0xFFC2: ("SOF2", "Progressive DCT", SOF),
  244. 0xFFC3: ("SOF3", "Spatial lossless", SOF),
  245. 0xFFC4: ("DHT", "Define Huffman table", Skip),
  246. 0xFFC5: ("SOF5", "Differential sequential DCT", SOF),
  247. 0xFFC6: ("SOF6", "Differential progressive DCT", SOF),
  248. 0xFFC7: ("SOF7", "Differential spatial", SOF),
  249. 0xFFC8: ("JPG", "Extension", None),
  250. 0xFFC9: ("SOF9", "Extended sequential DCT (AC)", SOF),
  251. 0xFFCA: ("SOF10", "Progressive DCT (AC)", SOF),
  252. 0xFFCB: ("SOF11", "Spatial lossless DCT (AC)", SOF),
  253. 0xFFCC: ("DAC", "Define arithmetic coding conditioning", Skip),
  254. 0xFFCD: ("SOF13", "Differential sequential DCT (AC)", SOF),
  255. 0xFFCE: ("SOF14", "Differential progressive DCT (AC)", SOF),
  256. 0xFFCF: ("SOF15", "Differential spatial (AC)", SOF),
  257. 0xFFD0: ("RST0", "Restart 0", None),
  258. 0xFFD1: ("RST1", "Restart 1", None),
  259. 0xFFD2: ("RST2", "Restart 2", None),
  260. 0xFFD3: ("RST3", "Restart 3", None),
  261. 0xFFD4: ("RST4", "Restart 4", None),
  262. 0xFFD5: ("RST5", "Restart 5", None),
  263. 0xFFD6: ("RST6", "Restart 6", None),
  264. 0xFFD7: ("RST7", "Restart 7", None),
  265. 0xFFD8: ("SOI", "Start of image", None),
  266. 0xFFD9: ("EOI", "End of image", None),
  267. 0xFFDA: ("SOS", "Start of scan", Skip),
  268. 0xFFDB: ("DQT", "Define quantization table", DQT),
  269. 0xFFDC: ("DNL", "Define number of lines", Skip),
  270. 0xFFDD: ("DRI", "Define restart interval", Skip),
  271. 0xFFDE: ("DHP", "Define hierarchical progression", SOF),
  272. 0xFFDF: ("EXP", "Expand reference component", Skip),
  273. 0xFFE0: ("APP0", "Application segment 0", APP),
  274. 0xFFE1: ("APP1", "Application segment 1", APP),
  275. 0xFFE2: ("APP2", "Application segment 2", APP),
  276. 0xFFE3: ("APP3", "Application segment 3", APP),
  277. 0xFFE4: ("APP4", "Application segment 4", APP),
  278. 0xFFE5: ("APP5", "Application segment 5", APP),
  279. 0xFFE6: ("APP6", "Application segment 6", APP),
  280. 0xFFE7: ("APP7", "Application segment 7", APP),
  281. 0xFFE8: ("APP8", "Application segment 8", APP),
  282. 0xFFE9: ("APP9", "Application segment 9", APP),
  283. 0xFFEA: ("APP10", "Application segment 10", APP),
  284. 0xFFEB: ("APP11", "Application segment 11", APP),
  285. 0xFFEC: ("APP12", "Application segment 12", APP),
  286. 0xFFED: ("APP13", "Application segment 13", APP),
  287. 0xFFEE: ("APP14", "Application segment 14", APP),
  288. 0xFFEF: ("APP15", "Application segment 15", APP),
  289. 0xFFF0: ("JPG0", "Extension 0", None),
  290. 0xFFF1: ("JPG1", "Extension 1", None),
  291. 0xFFF2: ("JPG2", "Extension 2", None),
  292. 0xFFF3: ("JPG3", "Extension 3", None),
  293. 0xFFF4: ("JPG4", "Extension 4", None),
  294. 0xFFF5: ("JPG5", "Extension 5", None),
  295. 0xFFF6: ("JPG6", "Extension 6", None),
  296. 0xFFF7: ("JPG7", "Extension 7", None),
  297. 0xFFF8: ("JPG8", "Extension 8", None),
  298. 0xFFF9: ("JPG9", "Extension 9", None),
  299. 0xFFFA: ("JPG10", "Extension 10", None),
  300. 0xFFFB: ("JPG11", "Extension 11", None),
  301. 0xFFFC: ("JPG12", "Extension 12", None),
  302. 0xFFFD: ("JPG13", "Extension 13", None),
  303. 0xFFFE: ("COM", "Comment", COM),
  304. }
  305. def _accept(prefix):
  306. # Magic number was taken from https://en.wikipedia.org/wiki/JPEG
  307. return prefix[:3] == b"\xFF\xD8\xFF"
  308. ##
  309. # Image plugin for JPEG and JFIF images.
  310. class JpegImageFile(ImageFile.ImageFile):
  311. format = "JPEG"
  312. format_description = "JPEG (ISO 10918)"
  313. def _open(self):
  314. s = self.fp.read(3)
  315. if not _accept(s):
  316. msg = "not a JPEG file"
  317. raise SyntaxError(msg)
  318. s = b"\xFF"
  319. # Create attributes
  320. self.bits = self.layers = 0
  321. # JPEG specifics (internal)
  322. self.layer = []
  323. self.huffman_dc = {}
  324. self.huffman_ac = {}
  325. self.quantization = {}
  326. self.app = {} # compatibility
  327. self.applist = []
  328. self.icclist = []
  329. while True:
  330. i = s[0]
  331. if i == 0xFF:
  332. s = s + self.fp.read(1)
  333. i = i16(s)
  334. else:
  335. # Skip non-0xFF junk
  336. s = self.fp.read(1)
  337. continue
  338. if i in MARKER:
  339. name, description, handler = MARKER[i]
  340. if handler is not None:
  341. handler(self, i)
  342. if i == 0xFFDA: # start of scan
  343. rawmode = self.mode
  344. if self.mode == "CMYK":
  345. rawmode = "CMYK;I" # assume adobe conventions
  346. self.tile = [("jpeg", (0, 0) + self.size, 0, (rawmode, ""))]
  347. # self.__offset = self.fp.tell()
  348. break
  349. s = self.fp.read(1)
  350. elif i == 0 or i == 0xFFFF:
  351. # padded marker or junk; move on
  352. s = b"\xff"
  353. elif i == 0xFF00: # Skip extraneous data (escaped 0xFF)
  354. s = self.fp.read(1)
  355. else:
  356. msg = "no marker found"
  357. raise SyntaxError(msg)
  358. def load_read(self, read_bytes):
  359. """
  360. internal: read more image data
  361. For premature EOF and LOAD_TRUNCATED_IMAGES adds EOI marker
  362. so libjpeg can finish decoding
  363. """
  364. s = self.fp.read(read_bytes)
  365. if not s and ImageFile.LOAD_TRUNCATED_IMAGES and not hasattr(self, "_ended"):
  366. # Premature EOF.
  367. # Pretend file is finished adding EOI marker
  368. self._ended = True
  369. return b"\xFF\xD9"
  370. return s
  371. def draft(self, mode, size):
  372. if len(self.tile) != 1:
  373. return
  374. # Protect from second call
  375. if self.decoderconfig:
  376. return
  377. d, e, o, a = self.tile[0]
  378. scale = 1
  379. original_size = self.size
  380. if a[0] == "RGB" and mode in ["L", "YCbCr"]:
  381. self.mode = mode
  382. a = mode, ""
  383. if size:
  384. scale = min(self.size[0] // size[0], self.size[1] // size[1])
  385. for s in [8, 4, 2, 1]:
  386. if scale >= s:
  387. break
  388. e = (
  389. e[0],
  390. e[1],
  391. (e[2] - e[0] + s - 1) // s + e[0],
  392. (e[3] - e[1] + s - 1) // s + e[1],
  393. )
  394. self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s)
  395. scale = s
  396. self.tile = [(d, e, o, a)]
  397. self.decoderconfig = (scale, 0)
  398. box = (0, 0, original_size[0] / scale, original_size[1] / scale)
  399. return self.mode, box
  400. def load_djpeg(self):
  401. # ALTERNATIVE: handle JPEGs via the IJG command line utilities
  402. f, path = tempfile.mkstemp()
  403. os.close(f)
  404. if os.path.exists(self.filename):
  405. subprocess.check_call(["djpeg", "-outfile", path, self.filename])
  406. else:
  407. msg = "Invalid Filename"
  408. raise ValueError(msg)
  409. try:
  410. with Image.open(path) as _im:
  411. _im.load()
  412. self.im = _im.im
  413. finally:
  414. try:
  415. os.unlink(path)
  416. except OSError:
  417. pass
  418. self.mode = self.im.mode
  419. self._size = self.im.size
  420. self.tile = []
  421. def _getexif(self):
  422. return _getexif(self)
  423. def _getmp(self):
  424. return _getmp(self)
  425. def getxmp(self):
  426. """
  427. Returns a dictionary containing the XMP tags.
  428. Requires defusedxml to be installed.
  429. :returns: XMP tags in a dictionary.
  430. """
  431. for segment, content in self.applist:
  432. if segment == "APP1":
  433. marker, xmp_tags = content.rsplit(b"\x00", 1)
  434. if marker == b"http://ns.adobe.com/xap/1.0/":
  435. return self._getxmp(xmp_tags)
  436. return {}
  437. def _getexif(self):
  438. if "exif" not in self.info:
  439. return None
  440. return self.getexif()._get_merged_dict()
  441. def _getmp(self):
  442. # Extract MP information. This method was inspired by the "highly
  443. # experimental" _getexif version that's been in use for years now,
  444. # itself based on the ImageFileDirectory class in the TIFF plugin.
  445. # The MP record essentially consists of a TIFF file embedded in a JPEG
  446. # application marker.
  447. try:
  448. data = self.info["mp"]
  449. except KeyError:
  450. return None
  451. file_contents = io.BytesIO(data)
  452. head = file_contents.read(8)
  453. endianness = ">" if head[:4] == b"\x4d\x4d\x00\x2a" else "<"
  454. # process dictionary
  455. from . import TiffImagePlugin
  456. try:
  457. info = TiffImagePlugin.ImageFileDirectory_v2(head)
  458. file_contents.seek(info.next)
  459. info.load(file_contents)
  460. mp = dict(info)
  461. except Exception as e:
  462. msg = "malformed MP Index (unreadable directory)"
  463. raise SyntaxError(msg) from e
  464. # it's an error not to have a number of images
  465. try:
  466. quant = mp[0xB001]
  467. except KeyError as e:
  468. msg = "malformed MP Index (no number of images)"
  469. raise SyntaxError(msg) from e
  470. # get MP entries
  471. mpentries = []
  472. try:
  473. rawmpentries = mp[0xB002]
  474. for entrynum in range(0, quant):
  475. unpackedentry = struct.unpack_from(
  476. f"{endianness}LLLHH", rawmpentries, entrynum * 16
  477. )
  478. labels = ("Attribute", "Size", "DataOffset", "EntryNo1", "EntryNo2")
  479. mpentry = dict(zip(labels, unpackedentry))
  480. mpentryattr = {
  481. "DependentParentImageFlag": bool(mpentry["Attribute"] & (1 << 31)),
  482. "DependentChildImageFlag": bool(mpentry["Attribute"] & (1 << 30)),
  483. "RepresentativeImageFlag": bool(mpentry["Attribute"] & (1 << 29)),
  484. "Reserved": (mpentry["Attribute"] & (3 << 27)) >> 27,
  485. "ImageDataFormat": (mpentry["Attribute"] & (7 << 24)) >> 24,
  486. "MPType": mpentry["Attribute"] & 0x00FFFFFF,
  487. }
  488. if mpentryattr["ImageDataFormat"] == 0:
  489. mpentryattr["ImageDataFormat"] = "JPEG"
  490. else:
  491. msg = "unsupported picture format in MPO"
  492. raise SyntaxError(msg)
  493. mptypemap = {
  494. 0x000000: "Undefined",
  495. 0x010001: "Large Thumbnail (VGA Equivalent)",
  496. 0x010002: "Large Thumbnail (Full HD Equivalent)",
  497. 0x020001: "Multi-Frame Image (Panorama)",
  498. 0x020002: "Multi-Frame Image: (Disparity)",
  499. 0x020003: "Multi-Frame Image: (Multi-Angle)",
  500. 0x030000: "Baseline MP Primary Image",
  501. }
  502. mpentryattr["MPType"] = mptypemap.get(mpentryattr["MPType"], "Unknown")
  503. mpentry["Attribute"] = mpentryattr
  504. mpentries.append(mpentry)
  505. mp[0xB002] = mpentries
  506. except KeyError as e:
  507. msg = "malformed MP Index (bad MP Entry)"
  508. raise SyntaxError(msg) from e
  509. # Next we should try and parse the individual image unique ID list;
  510. # we don't because I've never seen this actually used in a real MPO
  511. # file and so can't test it.
  512. return mp
  513. # --------------------------------------------------------------------
  514. # stuff to save JPEG files
  515. RAWMODE = {
  516. "1": "L",
  517. "L": "L",
  518. "RGB": "RGB",
  519. "RGBX": "RGB",
  520. "CMYK": "CMYK;I", # assume adobe conventions
  521. "YCbCr": "YCbCr",
  522. }
  523. # fmt: off
  524. zigzag_index = (
  525. 0, 1, 5, 6, 14, 15, 27, 28,
  526. 2, 4, 7, 13, 16, 26, 29, 42,
  527. 3, 8, 12, 17, 25, 30, 41, 43,
  528. 9, 11, 18, 24, 31, 40, 44, 53,
  529. 10, 19, 23, 32, 39, 45, 52, 54,
  530. 20, 22, 33, 38, 46, 51, 55, 60,
  531. 21, 34, 37, 47, 50, 56, 59, 61,
  532. 35, 36, 48, 49, 57, 58, 62, 63,
  533. )
  534. samplings = {
  535. (1, 1, 1, 1, 1, 1): 0,
  536. (2, 1, 1, 1, 1, 1): 1,
  537. (2, 2, 1, 1, 1, 1): 2,
  538. }
  539. # fmt: on
  540. def convert_dict_qtables(qtables):
  541. deprecate("convert_dict_qtables", 10, action="Conversion is no longer needed")
  542. return qtables
  543. def get_sampling(im):
  544. # There's no subsampling when images have only 1 layer
  545. # (grayscale images) or when they are CMYK (4 layers),
  546. # so set subsampling to the default value.
  547. #
  548. # NOTE: currently Pillow can't encode JPEG to YCCK format.
  549. # If YCCK support is added in the future, subsampling code will have
  550. # to be updated (here and in JpegEncode.c) to deal with 4 layers.
  551. if not hasattr(im, "layers") or im.layers in (1, 4):
  552. return -1
  553. sampling = im.layer[0][1:3] + im.layer[1][1:3] + im.layer[2][1:3]
  554. return samplings.get(sampling, -1)
  555. def _save(im, fp, filename):
  556. if im.width == 0 or im.height == 0:
  557. msg = "cannot write empty image as JPEG"
  558. raise ValueError(msg)
  559. try:
  560. rawmode = RAWMODE[im.mode]
  561. except KeyError as e:
  562. msg = f"cannot write mode {im.mode} as JPEG"
  563. raise OSError(msg) from e
  564. info = im.encoderinfo
  565. dpi = [round(x) for x in info.get("dpi", (0, 0))]
  566. quality = info.get("quality", -1)
  567. subsampling = info.get("subsampling", -1)
  568. qtables = info.get("qtables")
  569. if quality == "keep":
  570. quality = -1
  571. subsampling = "keep"
  572. qtables = "keep"
  573. elif quality in presets:
  574. preset = presets[quality]
  575. quality = -1
  576. subsampling = preset.get("subsampling", -1)
  577. qtables = preset.get("quantization")
  578. elif not isinstance(quality, int):
  579. msg = "Invalid quality setting"
  580. raise ValueError(msg)
  581. else:
  582. if subsampling in presets:
  583. subsampling = presets[subsampling].get("subsampling", -1)
  584. if isinstance(qtables, str) and qtables in presets:
  585. qtables = presets[qtables].get("quantization")
  586. if subsampling == "4:4:4":
  587. subsampling = 0
  588. elif subsampling == "4:2:2":
  589. subsampling = 1
  590. elif subsampling == "4:2:0":
  591. subsampling = 2
  592. elif subsampling == "4:1:1":
  593. # For compatibility. Before Pillow 4.3, 4:1:1 actually meant 4:2:0.
  594. # Set 4:2:0 if someone is still using that value.
  595. subsampling = 2
  596. elif subsampling == "keep":
  597. if im.format != "JPEG":
  598. msg = "Cannot use 'keep' when original image is not a JPEG"
  599. raise ValueError(msg)
  600. subsampling = get_sampling(im)
  601. def validate_qtables(qtables):
  602. if qtables is None:
  603. return qtables
  604. if isinstance(qtables, str):
  605. try:
  606. lines = [
  607. int(num)
  608. for line in qtables.splitlines()
  609. for num in line.split("#", 1)[0].split()
  610. ]
  611. except ValueError as e:
  612. msg = "Invalid quantization table"
  613. raise ValueError(msg) from e
  614. else:
  615. qtables = [lines[s : s + 64] for s in range(0, len(lines), 64)]
  616. if isinstance(qtables, (tuple, list, dict)):
  617. if isinstance(qtables, dict):
  618. qtables = [
  619. qtables[key] for key in range(len(qtables)) if key in qtables
  620. ]
  621. elif isinstance(qtables, tuple):
  622. qtables = list(qtables)
  623. if not (0 < len(qtables) < 5):
  624. msg = "None or too many quantization tables"
  625. raise ValueError(msg)
  626. for idx, table in enumerate(qtables):
  627. try:
  628. if len(table) != 64:
  629. raise TypeError
  630. table = array.array("H", table)
  631. except TypeError as e:
  632. msg = "Invalid quantization table"
  633. raise ValueError(msg) from e
  634. else:
  635. qtables[idx] = list(table)
  636. return qtables
  637. if qtables == "keep":
  638. if im.format != "JPEG":
  639. msg = "Cannot use 'keep' when original image is not a JPEG"
  640. raise ValueError(msg)
  641. qtables = getattr(im, "quantization", None)
  642. qtables = validate_qtables(qtables)
  643. extra = info.get("extra", b"")
  644. MAX_BYTES_IN_MARKER = 65533
  645. icc_profile = info.get("icc_profile")
  646. if icc_profile:
  647. ICC_OVERHEAD_LEN = 14
  648. MAX_DATA_BYTES_IN_MARKER = MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN
  649. markers = []
  650. while icc_profile:
  651. markers.append(icc_profile[:MAX_DATA_BYTES_IN_MARKER])
  652. icc_profile = icc_profile[MAX_DATA_BYTES_IN_MARKER:]
  653. i = 1
  654. for marker in markers:
  655. size = o16(2 + ICC_OVERHEAD_LEN + len(marker))
  656. extra += (
  657. b"\xFF\xE2"
  658. + size
  659. + b"ICC_PROFILE\0"
  660. + o8(i)
  661. + o8(len(markers))
  662. + marker
  663. )
  664. i += 1
  665. comment = info.get("comment", im.info.get("comment"))
  666. # "progressive" is the official name, but older documentation
  667. # says "progression"
  668. # FIXME: issue a warning if the wrong form is used (post-1.1.7)
  669. progressive = info.get("progressive", False) or info.get("progression", False)
  670. optimize = info.get("optimize", False)
  671. exif = info.get("exif", b"")
  672. if isinstance(exif, Image.Exif):
  673. exif = exif.tobytes()
  674. if len(exif) > MAX_BYTES_IN_MARKER:
  675. msg = "EXIF data is too long"
  676. raise ValueError(msg)
  677. # get keyword arguments
  678. im.encoderconfig = (
  679. quality,
  680. progressive,
  681. info.get("smooth", 0),
  682. optimize,
  683. info.get("streamtype", 0),
  684. dpi[0],
  685. dpi[1],
  686. subsampling,
  687. qtables,
  688. comment,
  689. extra,
  690. exif,
  691. )
  692. # if we optimize, libjpeg needs a buffer big enough to hold the whole image
  693. # in a shot. Guessing on the size, at im.size bytes. (raw pixel size is
  694. # channels*size, this is a value that's been used in a django patch.
  695. # https://github.com/matthewwithanm/django-imagekit/issues/50
  696. bufsize = 0
  697. if optimize or progressive:
  698. # CMYK can be bigger
  699. if im.mode == "CMYK":
  700. bufsize = 4 * im.size[0] * im.size[1]
  701. # keep sets quality to -1, but the actual value may be high.
  702. elif quality >= 95 or quality == -1:
  703. bufsize = 2 * im.size[0] * im.size[1]
  704. else:
  705. bufsize = im.size[0] * im.size[1]
  706. # The EXIF info needs to be written as one block, + APP1, + one spare byte.
  707. # Ensure that our buffer is big enough. Same with the icc_profile block.
  708. bufsize = max(ImageFile.MAXBLOCK, bufsize, len(exif) + 5, len(extra) + 1)
  709. ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize)
  710. def _save_cjpeg(im, fp, filename):
  711. # ALTERNATIVE: handle JPEGs via the IJG command line utilities.
  712. tempfile = im._dump()
  713. subprocess.check_call(["cjpeg", "-outfile", filename, tempfile])
  714. try:
  715. os.unlink(tempfile)
  716. except OSError:
  717. pass
  718. ##
  719. # Factory for making JPEG and MPO instances
  720. def jpeg_factory(fp=None, filename=None):
  721. im = JpegImageFile(fp, filename)
  722. try:
  723. mpheader = im._getmp()
  724. if mpheader[45057] > 1:
  725. # It's actually an MPO
  726. from .MpoImagePlugin import MpoImageFile
  727. # Don't reload everything, just convert it.
  728. im = MpoImageFile.adopt(im, mpheader)
  729. except (TypeError, IndexError):
  730. # It is really a JPEG
  731. pass
  732. except SyntaxError:
  733. warnings.warn(
  734. "Image appears to be a malformed MPO file, it will be "
  735. "interpreted as a base JPEG file"
  736. )
  737. return im
  738. # ---------------------------------------------------------------------
  739. # Registry stuff
  740. Image.register_open(JpegImageFile.format, jpeg_factory, _accept)
  741. Image.register_save(JpegImageFile.format, _save)
  742. Image.register_extensions(JpegImageFile.format, [".jfif", ".jpe", ".jpg", ".jpeg"])
  743. Image.register_mime(JpegImageFile.format, "image/jpeg")