def _initPIL(): global _pilInited, _imgFormats, _imgTypes if _pilInited: return if NEED_AKJPEG: akjpeg.hw_init() Image.preinit() _imgFormats = Image.EXTENSION Image.register_mime("BMP", "image/bmp") Image.register_mime("PPM", "image/x-portable-pixmap") _imgTypes = {} for key, val in _imgFormats.iteritems(): _imgTypes[key] = Image.MIME[val] _pilInited = True
def test_imagefield_annotate_with_bitmap_image_after_clean(self): """ This also tests the situation when Pillow doesn't detect the MIME type of the image (#24948). """ from PIL.BmpImagePlugin import BmpImageFile try: Image.register_mime(BmpImageFile.format, None) f = ImageField() img_path = get_img_path('filepath_test_files/1x1.bmp') with open(img_path, 'rb') as img_file: img_data = img_file.read() img_file = SimpleUploadedFile('1x1.bmp', img_data) img_file.content_type = 'text/plain' uploaded_file = f.clean(img_file) self.assertEqual('BMP', uploaded_file.image.format) self.assertIsNone(uploaded_file.content_type) finally: Image.register_mime(BmpImageFile.format, 'image/bmp')
def load_seek(self, pos): self.__fp.seek(pos) def seek(self, frame): if frame < 0 or frame >= self.__framecount: raise EOFError("no more images in MPO file") else: self.fp = self.__fp self.offset = self.__mpoffsets[frame] self.tile = [ ("jpeg", (0, 0) + self.size, self.offset, (self.mode, "")) ] self.__frame = frame def tell(self): return self.__frame # -------------------------------------------------------------------q- # Registry stuff # Note that since MPO shares a factory with JPEG, we do not need to do a # separate registration for it here. #Image.register_open("MPO", JpegImagePlugin.jpeg_factory, _accept) Image.register_save("MPO", _save) Image.register_extension("MPO", ".mpo") Image.register_mime("MPO", "image/mpo")
def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open("PNG", PngImageFile, _accept) Image.register_save("PNG", _save) Image.register_extension("PNG", ".png") Image.register_mime("PNG", "image/png")
retcode = convert_proc.wait() # remove the temporary files shutil.rmtree(iconset) if retcode: raise CalledProcessError(retcode, convert_cmd) Image.register_open(IcnsImageFile.format, IcnsImageFile, lambda x: x[:4] == b'icns') Image.register_extension(IcnsImageFile.format, '.icns') if sys.platform == 'darwin': Image.register_save(IcnsImageFile.format, _save) Image.register_mime(IcnsImageFile.format, "image/icns") if __name__ == '__main__': imf = IcnsImageFile(open(sys.argv[1], 'rb')) for size in imf.info['sizes']: imf.size = size imf.load() im = imf.im im.save('out-%s-%s-%s.png' % size) im = Image.open(open(sys.argv[1], "rb")) im.save("out.png") if sys.platform == 'windows': os.startfile("out.png")
self.tile = [("raw", (0, 0) + self.size, 0, self.mode)] def _save(im, fp, filename): quality = im.encoderinfo.get("quality", 80) if im.mode == "RGB": data = WebPEncodeRGB(im.tobytes(), im.size[0], im.size[1], im.size[0] * 3, float(quality)) elif im.mode == "RGBA": data = WebPEncodeRGBA(im.tobytes(), im.size[0], im.size[1], im.size[0] * 4, float(quality)) else: raise IOError("cannot write mode %s as WEBP" % im.mode) fp.write(data) def explicitRegisterOnPIL(ImageClass): """ Instead of monkeypatching on import, this function lets you send the PIL.Image class and explicitly register on it """ ImageClass.register_open("WEBP", WebPImageFile, _accept) ImageClass.register_save("WEBP", _save) ImageClass.register_extension("WEBP", ".webp") ImageClass.register_mime("WEBP", "image/webp") Image.register_open("WEBP", WebPImageFile, _accept) Image.register_save("WEBP", _save) Image.register_extension("WEBP", ".webp") Image.register_mime("WEBP", "image/webp")
if not _fp: fp.write(d) if s: break if s < 0: raise IOError("encoder error %d when writing image file" % s) else: offset = ifd.save(fp) ImageFile._save(im, fp, [ ("raw", (0, 0)+im.size, offset, (rawmode, stride, 1)) ]) # -- helper for multi-page save -- if "_debug_multipage" in im.encoderinfo: # just to access o32 and o16 (using correct byte order) im._debug_multipage = ifd # # -------------------------------------------------------------------- # Register Image.register_open(TiffImageFile.format, TiffImageFile, _accept) Image.register_save(TiffImageFile.format, _save) Image.register_extension(TiffImageFile.format, ".tif") Image.register_extension(TiffImageFile.format, ".tiff") Image.register_mime(TiffImageFile.format, "image/tiff")
# # image header fp.write("gsave\n") fp.write("10 dict begin\n") fp.write("/buf %d string def\n" % (im.size[0] * operator[1])) fp.write("%d %d scale\n" % im.size) fp.write("%d %d 8\n" % im.size) # <= bits fp.write("[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1])) fp.write("{ currentfile buf readhexstring pop } bind\n") fp.write(operator[2] + "\n") fp.flush() ImageFile._save(im, base_fp, [("eps", (0, 0)+im.size, 0, None)]) fp.write("\n%%%%EndBinary\n") fp.write("grestore end\n") fp.flush() # # -------------------------------------------------------------------- Image.register_open(EpsImageFile.format, EpsImageFile, _accept) Image.register_save(EpsImageFile.format, _save) Image.register_extension(EpsImageFile.format, ".ps") Image.register_extension(EpsImageFile.format, ".eps") Image.register_mime(EpsImageFile.format, "application/postscript")
if hasattr(fp, "fileno"): try: fd = fp.fileno() except: fd = -1 im.encoderconfig = (offset, tile_offset, tile_size, quality_mode, quality_layers, num_resolutions, cblk_size, precinct_size, irreversible, progression, cinema_mode, fd) ImageFile._save(im, fp, [('jpeg2k', (0, 0) + im.size, 0, kind)]) # ------------------------------------------------------------ # Registry stuff Image.register_open(Jpeg2KImageFile.format, Jpeg2KImageFile, _accept) Image.register_save(Jpeg2KImageFile.format, _save) Image.register_extension(Jpeg2KImageFile.format, '.jp2') Image.register_extension(Jpeg2KImageFile.format, '.j2k') Image.register_extension(Jpeg2KImageFile.format, '.jpc') Image.register_extension(Jpeg2KImageFile.format, '.jpf') Image.register_extension(Jpeg2KImageFile.format, '.jpx') Image.register_extension(Jpeg2KImageFile.format, '.j2c') Image.register_mime(Jpeg2KImageFile.format, 'image/jp2') Image.register_mime(Jpeg2KImageFile.format, 'image/jpx')
struct.pack(">4sIH?H", b"030\x00", 17 + length, len(frames_buffers), 0, 1 if len(positions) > 1 else 0)) for buf in frames_buffers: fp.write(buf) def _debug(image): print('Info' + str(image.info)) for i in range(image.n_frames): image.seek(i) print("Frame #%d: mode: %s size=%dx%d" % (i, image.mode, image.size[0], image.size[1])) print("\tHeader: ", image.header) # # Registration # Image.register_open(FACImageFile.format, FACImageFile, _accept) Image.register_save(FACImageFile.format, _save) Image.register_save_all(FACImageFile.format, _save_all) Image.register_extension(FACImageFile.format, ".fac") Image.register_mime(FACImageFile.format, "image/fac") if __name__ == "__main__": import doctest doctest.testmod()
tile_offset, tile_size, quality_mode, quality_layers, num_resolutions, cblk_size, precinct_size, irreversible, progression, cinema_mode, fd ) ImageFile._save(im, fp, [('jpeg2k', (0, 0)+im.size, 0, kind)]) # ------------------------------------------------------------ # Registry stuff Image.register_open(Jpeg2KImageFile.format, Jpeg2KImageFile, _accept) Image.register_save(Jpeg2KImageFile.format, _save) Image.register_extension(Jpeg2KImageFile.format, '.jp2') Image.register_extension(Jpeg2KImageFile.format, '.j2k') Image.register_extension(Jpeg2KImageFile.format, '.jpc') Image.register_extension(Jpeg2KImageFile.format, '.jpf') Image.register_extension(Jpeg2KImageFile.format, '.jpx') Image.register_extension(Jpeg2KImageFile.format, '.j2c') Image.register_mime(Jpeg2KImageFile.format, 'image/jp2') Image.register_mime(Jpeg2KImageFile.format, 'image/jpx')
def is_animated(self): return self.__framecount > 1 def seek(self, frame): if frame < 0 or frame >= self.__framecount: raise EOFError("no more images in MPO file") else: self.fp = self.__fp self.offset = self.__mpoffsets[frame] self.tile = [ ("jpeg", (0, 0) + self.size, self.offset, (self.mode, "")) ] self.__frame = frame def tell(self): return self.__frame # -------------------------------------------------------------------q- # Registry stuff # Note that since MPO shares a factory with JPEG, we do not need to do a # separate registration for it here. # Image.register_open(MpoImageFile.format, # JpegImagePlugin.jpeg_factory, _accept) Image.register_save(MpoImageFile.format, _save) Image.register_extension(MpoImageFile.format, ".mpo") Image.register_mime(MpoImageFile.format, "image/mpo")
fp.write(struct.pack('79s', imgName)) # truncates to 79 chars fp.write(struct.pack('s', b'')) # force null byte after imgname fp.write(struct.pack('>l', colormap)) fp.write(struct.pack('404s', b'')) # dummy #assert we've got the right number of bands. if len(im.getbands()) != z: raise ValueError("incorrect number of bands in SGI write: %s vs %s" % (z, len(im.getbands()))) for channel in im.split(): fp.write(channel.tobytes()) fp.close() # # registry Image.register_open(SgiImageFile.format, SgiImageFile, _accept) Image.register_save(SgiImageFile.format, _save) Image.register_mime(SgiImageFile.format, "image/sgi") Image.register_mime(SgiImageFile.format, "image/rgb") Image.register_extension(SgiImageFile.format, ".bw") Image.register_extension(SgiImageFile.format, ".rgb") Image.register_extension(SgiImageFile.format, ".rgba") Image.register_extension(SgiImageFile.format, ".sgi") # End of file
self.mode = "P" self.palette = ImagePalette.raw("RGB", b"".join(palette)) self.tile = [("raw", (0, 0)+self.size, self.fp.tell(), ("P", 0, 1))] def load_read(self, bytes): # # load all image data in one chunk xsize, ysize = self.size s = [None] * ysize for i in range(ysize): s[i] = self.fp.readline()[1:xsize+1].ljust(xsize) self.fp = None return b"".join(s) # # Registry Image.register_open(XpmImageFile.format, XpmImageFile, _accept) Image.register_extension(XpmImageFile.format, ".xpm") Image.register_mime(XpmImageFile.format, "image/xpm")
convert_proc.stdout.close() retcode = convert_proc.wait() # remove the temporary files shutil.rmtree(iconset) if retcode: raise CalledProcessError(retcode, convert_cmd) Image.register_open("ICNS", IcnsImageFile, lambda x: x[:4] == b'icns') Image.register_extension("ICNS", '.icns') if sys.platform == 'darwin': Image.register_save("ICNS", _save) Image.register_mime("ICNS", "image/icns") if __name__ == '__main__': imf = IcnsImageFile(open(sys.argv[1], 'rb')) for size in imf.info['sizes']: imf.size = size imf.load() im = imf.im im.save('out-%s-%s-%s.png' % size) im = Image.open(open(sys.argv[1], "rb")) im.save("out.png") if sys.platform == 'windows': os.startfile("out.png")
# Factory for making JPEG and MPO instances def jpeg_factory(fp=None, filename=None): im = JpegImageFile(fp, filename) try: mpheader = im._getmp() if mpheader[45057] > 1: # It's actually an MPO from .MpoImagePlugin import MpoImageFile im = MpoImageFile(fp, filename) except (TypeError, IndexError): # It is really a JPEG pass except SyntaxError: warnings.warn("Image appears to be a malformed MPO file, it will be " "interpreted as a base JPEG file") return im # -------------------------------------------------------------------q- # Registry stuff Image.register_open(JpegImageFile.format, jpeg_factory, _accept) Image.register_save(JpegImageFile.format, _save) Image.register_extension(JpegImageFile.format, ".jfif") Image.register_extension(JpegImageFile.format, ".jpe") Image.register_extension(JpegImageFile.format, ".jpg") Image.register_extension(JpegImageFile.format, ".jpeg") Image.register_mime(JpegImageFile.format, "image/jpeg")
image_mode = im.mode if im.mode not in _VALID_WEBP_MODES: raise IOError("cannot write mode %s as WEBP" % image_mode) lossless = im.encoderinfo.get("lossless", False) quality = im.encoderinfo.get("quality", 80) icc_profile = im.encoderinfo.get("icc_profile", "") exif = im.encoderinfo.get("exif", "") data = _webp.WebPEncode( im.tobytes(), im.size[0], im.size[1], lossless, float(quality), im.mode, icc_profile, exif ) if data is None: raise IOError("cannot write file as WEBP (encoder returned None)") fp.write(data) Image.register_open(WebPImageFile.format, WebPImageFile, _accept) Image.register_save(WebPImageFile.format, _save) Image.register_extension(WebPImageFile.format, ".webp") Image.register_mime(WebPImageFile.format, "image/webp")
self.mode = "P" self.palette = ImagePalette.raw("RGB", b"".join(palette)) self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))] def load_read(self, bytes): # # load all image data in one chunk xsize, ysize = self.size s = [None] * ysize for i in range(ysize): s[i] = self.fp.readline()[1:xsize + 1].ljust(xsize) self.fp = None return b"".join(s) # # Registry Image.register_open("XPM", XpmImageFile, _accept) Image.register_extension("XPM", ".xpm") Image.register_mime("XPM", "image/xpm")
## # Image plugin for MPEG streams. This plugin can identify a stream, # but it cannot read it. class MpegImageFile(ImageFile.ImageFile): format = "MPEG" format_description = "MPEG" def _open(self): s = BitStream(self.fp) if s.read(32) != 0x1B3: raise SyntaxError("not an MPEG file") self.mode = "RGB" self.size = s.read(12), s.read(12) # -------------------------------------------------------------------- # Registry stuff Image.register_open("MPEG", MpegImageFile) Image.register_extension("MPEG", ".mpg") Image.register_extension("MPEG", ".mpeg") Image.register_mime("MPEG", "video/mpeg")
self.mode = "P" self.palette = ImagePalette.raw("RGB", b"".join(palette)) self.tile = [("raw", (0, 0)+self.size, self.fp.tell(), ("P", 0, 1))] def load_read(self, bytes): # # load all image data in one chunk xsize, ysize = self.size s = [None] * ysize for i in range(ysize): s[i] = self.fp.readline()[1:xsize+1].ljust(xsize) self.fp = None return b"".join(s) # # Registry Image.register_open("XPM", XpmImageFile, _accept) Image.register_extension("XPM", ".xpm") Image.register_mime("XPM", "image/xpm")
self.fp = BytesIO(data) self.tile = [("raw", (0, 0) + self.size, 0, self.mode)] def _getexif(self): from PIL.JpegImagePlugin import _getexif return _getexif(self) def _save(im, fp, filename): image_mode = im.mode if im.mode not in _VALID_WEBP_MODES: raise IOError("cannot write mode %s as WEBP" % image_mode) quality = im.encoderinfo.get("quality", 80) icc_profile = im.encoderinfo.get("icc_profile", "") exif = im.encoderinfo.get("exif", "") data = _webp.WebPEncode(im.tobytes(), im.size[0], im.size[1], float(quality), im.mode, icc_profile, exif) if data is None: raise IOError("cannot write file as WEBP (encoder returned None)") fp.write(data) Image.register_open("WEBP", WebPImageFile, _accept) Image.register_save("WEBP", _save) Image.register_extension("WEBP", ".webp") Image.register_mime("WEBP", "image/webp")
if not _fp: fp.write(d) if s: break if s < 0: raise IOError("encoder error %d when writing image file" % s) else: offset = ifd.save(fp) ImageFile._save(im, fp, [("raw", (0, 0) + im.size, offset, (rawmode, stride, 1))]) # -- helper for multi-page save -- if "_debug_multipage" in im.encoderinfo: # just to access o32 and o16 (using correct byte order) im._debug_multipage = ifd # # -------------------------------------------------------------------- # Register Image.register_open(TiffImageFile.format, TiffImageFile, _accept) Image.register_save(TiffImageFile.format, _save) Image.register_extension(TiffImageFile.format, ".tif") Image.register_extension(TiffImageFile.format, ".tiff") Image.register_mime(TiffImageFile.format, "image/tiff")
# Ensure that our buffer is big enough bufsize = max(ImageFile.MAXBLOCK, bufsize, len(info.get("exif", b"")) + 5) ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize) def _save_cjpeg(im, fp, filename): # ALTERNATIVE: handle JPEGs via the IJG command line utilities. import os file = im._dump() os.system("cjpeg %s >%s" % (file, filename)) try: os.unlink(file) except: pass # -------------------------------------------------------------------q- # Registry stuff Image.register_open("JPEG", JpegImageFile, _accept) Image.register_save("JPEG", _save) Image.register_extension("JPEG", ".jfif") Image.register_extension("JPEG", ".jpe") Image.register_extension("JPEG", ".jpg") Image.register_extension("JPEG", ".jpeg") Image.register_mime("JPEG", "image/jpeg")
self.tile = [("xbm", (0, 0) + self.size, m.end(), None)] def _save(im, fp, filename): if im.mode != "1": raise IOError("cannot write mode %s as XBM" % im.mode) fp.write(("#define im_width %d\n" % im.size[0]).encode('ascii')) fp.write(("#define im_height %d\n" % im.size[1]).encode('ascii')) hotspot = im.encoderinfo.get("hotspot") if hotspot: fp.write(("#define im_x_hot %d\n" % hotspot[0]).encode('ascii')) fp.write(("#define im_y_hot %d\n" % hotspot[1]).encode('ascii')) fp.write(b"static char im_bits[] = {\n") ImageFile._save(im, fp, [("xbm", (0, 0) + im.size, 0, None)]) fp.write(b"};\n") Image.register_open("XBM", XbmImageFile, _accept) Image.register_save("XBM", _save) Image.register_extension("XBM", ".xbm") Image.register_mime("XBM", "image/xbm")
from PIL import Image, ImageFile # workaround initialization code from PIL.GifImagePlugin import GifImageFile, _accept, _save, _save_all class AnimatedGifImageFile(GifImageFile): def load_end(self): ImageFile.ImageFile.load_end(self) Image.register_open(AnimatedGifImageFile.format, AnimatedGifImageFile, _accept) Image.register_save(AnimatedGifImageFile.format, _save) Image.register_save_all(AnimatedGifImageFile.format, _save_all) Image.register_extension(AnimatedGifImageFile.format, ".gif") Image.register_mime(AnimatedGifImageFile.format, "image/gif") # end of workaround initialization code def get_frames(gif: Image.Image) -> List[Image.Image]: """ Extract all frames from gif. This function is just slight adjustment of the for-cycle from the workaround. """ last_frame = None all_frames = [] i = 0 try: while True:
# Write out the data for this frame to the output data_descriptor = QGFFrameDataDescriptorV1() data_descriptor.data = image_data vprint( f'{f"Frame {idx:3d} data":26s} {fp.tell():5d}d / {fp.tell():04X}h') data_descriptor.write(fp) # Iterate over each if the input frames, writing it to the output in the process _for_all_frames(_write_frame) # Go back and update the graphics descriptor now that we can determine the final file size graphics_descriptor.total_file_size = fp.tell() fp.seek(graphics_descriptor_location, 0) graphics_descriptor.write(fp) # Go back and update the frame offsets now that they're written to the file fp.seek(frame_offset_location, 0) frame_offsets.write(fp) ######################################################################################################################## # Register with PIL so that it knows about the QGF format Image.register_open(QGFImageFile.format, QGFImageFile, _accept) Image.register_save(QGFImageFile.format, _save) Image.register_save_all(QGFImageFile.format, _save) Image.register_extension(QGFImageFile.format, f".{QGFImageFile.format.lower()}") Image.register_mime(QGFImageFile.format, f"image/{QGFImageFile.format.lower()}")
self.tile = [("xbm", (0, 0) + self.size, m.end(), None)] def _save(im, fp, filename): if im.mode != "1": raise IOError("cannot write mode %s as XBM" % im.mode) fp.write(("#define im_width %d\n" % im.size[0]).encode("ascii")) fp.write(("#define im_height %d\n" % im.size[1]).encode("ascii")) hotspot = im.encoderinfo.get("hotspot") if hotspot: fp.write(("#define im_x_hot %d\n" % hotspot[0]).encode("ascii")) fp.write(("#define im_y_hot %d\n" % hotspot[1]).encode("ascii")) fp.write(b"static char im_bits[] = {\n") ImageFile._save(im, fp, [("xbm", (0, 0) + im.size, 0, None)]) fp.write(b"};\n") Image.register_open(XbmImageFile.format, XbmImageFile, _accept) Image.register_save(XbmImageFile.format, _save) Image.register_extension(XbmImageFile.format, ".xbm") Image.register_mime(XbmImageFile.format, "image/xbm")
if hasattr(fp, "fileno"): try: fd = fp.fileno() except: fd = -1 im.encoderconfig = (offset, tile_offset, tile_size, quality_mode, quality_layers, num_resolutions, cblk_size, precinct_size, irreversible, progression, cinema_mode, fd) ImageFile._save(im, fp, [('jpeg2k', (0, 0) + im.size, 0, kind)]) # ------------------------------------------------------------ # Registry stuff Image.register_open('JPEG2000', Jpeg2KImageFile, _accept) Image.register_save('JPEG2000', _save) Image.register_extension('JPEG2000', '.jp2') Image.register_extension('JPEG2000', '.j2k') Image.register_extension('JPEG2000', '.jpc') Image.register_extension('JPEG2000', '.jpf') Image.register_extension('JPEG2000', '.jpx') Image.register_extension('JPEG2000', '.j2c') Image.register_mime('JPEG2000', 'image/jp2') Image.register_mime('JPEG2000', 'image/jpx')
def register_heif_opener(): Image.register_open(HeifImageFile.format, HeifImageFile, RawHeifImage.check_file_type) Image.register_decoder('heif', HeifDecoder) Image.register_extensions(HeifImageFile.format, ['.heic', '.heif']) Image.register_mime(HeifImageFile.format, 'image/heif')
op.write("q %d 0 0 %d 0 0 cm /image Do Q\n" % (int(width * 72.0 / resolution), int(height * 72.0 / resolution))) xref[5] = fp.tell() _obj(fp, 5, Length = len(op.fp.getvalue())) fp.write("stream\n") fp.fp.write(op.fp.getvalue()) fp.write("\nendstream\n") _endobj(fp) # # trailer startxref = fp.tell() fp.write("xref\n0 %d\n0000000000 65535 f \n" % len(xref)) for x in xref[1:]: fp.write("%010d 00000 n \n" % x) fp.write("trailer\n<<\n/Size %d\n/Root 1 0 R\n>>\n" % len(xref)) fp.write("startxref\n%d\n%%%%EOF\n" % startxref) fp.flush() # # -------------------------------------------------------------------- Image.register_save("PDF", _save) Image.register_extension("PDF", ".pdf") Image.register_mime("PDF", "application/pdf")
def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open(PngImageFile.format, PngImageFile, _accept) Image.register_save(PngImageFile.format, _save) Image.register_extension(PngImageFile.format, ".png") Image.register_mime(PngImageFile.format, "image/png")
## # Factory for making JPEG and MPO instances def jpeg_factory(fp=None, filename=None): im = JpegImageFile(fp, filename) mpheader = im._getmp() try: if mpheader[45057] > 1: # It's actually an MPO from .MpoImagePlugin import MpoImageFile im = MpoImageFile(fp, filename) except (TypeError, IndexError): # It is really a JPEG pass return im # -------------------------------------------------------------------q- # Registry stuff Image.register_open("JPEG", jpeg_factory, _accept) Image.register_save("JPEG", _save) Image.register_extension("JPEG", ".jfif") Image.register_extension("JPEG", ".jpe") Image.register_extension("JPEG", ".jpg") Image.register_extension("JPEG", ".jpeg") Image.register_mime("JPEG", "image/jpeg")
if colormapsize > 0: fp.write(o16b(256)) for i in range(256): fp.write(o8(i)) if colormapmode == 'RGB': fp.write( o8(colormap[3 * i]) + o8(colormap[3 * i + 1]) + o8(colormap[3 * i + 2])) elif colormapmode == 'RGBA': fp.write( o8(colormap[4 * i]) + o8(colormap[4 * i + 1]) + o8(colormap[4 * i + 2])) # now convert data to raw form ImageFile._save( im, fp, [("raw", (0, 0)+im.size, 0, (rawmode, rowbytes, 1))]) fp.flush() # # -------------------------------------------------------------------- Image.register_save("Palm", _save) Image.register_extension("Palm", ".palm") Image.register_mime("Palm", "image/palm")
if not _fp: fp.write(d) if s: break if s < 0: raise IOError("encoder error %d when writing image file" % s) else: offset = ifd.save(fp) ImageFile._save(im, fp, [ ("raw", (0, 0)+im.size, offset, (rawmode, stride, 1)) ]) # -- helper for multi-page save -- if "_debug_multipage" in im.encoderinfo: # just to access o32 and o16 (using correct byte order) im._debug_multipage = ifd # # -------------------------------------------------------------------- # Register Image.register_open("TIFF", TiffImageFile, _accept) Image.register_save("TIFF", _save) Image.register_extension("TIFF", ".tif") Image.register_extension("TIFF", ".tiff") Image.register_mime("TIFF", "image/tiff")
def url_fetcher(url, resource_type): if url.startswith("data:"): return fetch(url, resource_type) return b"" def svg_image_factory(fp, filename): mime_type = magic.from_buffer(fp.read(1024), mime=True) if mime_type != "image/svg+xml": raise TypeError fp.seek(0) png_data = PNGSurface.convert(fp.read(), url_fetcher=url_fetcher) return PngImageFile(BytesIO(png_data)) Image.register_mime("SVG", "image/svg+xml") Image.register_extension("SVG", ".svg") Image.register_open("SVG", svg_image_factory) except Exception: pass Image.init() # PSD thumbnail generator def psd_image_factory(data, *args): try: return PSDImage.from_stream(data).as_PIL() except Exception: raise TypeError Image.register_open("PSD", psd_image_factory)
self.tile = [("xbm", (0, 0)+self.size, m.end(), None)] def _save(im, fp, filename): if im.mode != "1": raise IOError("cannot write mode %s as XBM" % im.mode) fp.write(("#define im_width %d\n" % im.size[0]).encode('ascii')) fp.write(("#define im_height %d\n" % im.size[1]).encode('ascii')) hotspot = im.encoderinfo.get("hotspot") if hotspot: fp.write(("#define im_x_hot %d\n" % hotspot[0]).encode('ascii')) fp.write(("#define im_y_hot %d\n" % hotspot[1]).encode('ascii')) fp.write(b"static char im_bits[] = {\n") ImageFile._save(im, fp, [("xbm", (0, 0)+im.size, 0, None)]) fp.write(b"};\n") Image.register_open("XBM", XbmImageFile, _accept) Image.register_save("XBM", _save) Image.register_extension("XBM", ".xbm") Image.register_mime("XBM", "image/xbm")
0x50 ]), ] @staticmethod def check(first_bytes: Union[bytes, bytearray]): return (first_bytes[:4] == WebpFileTypeChecker.magic_bytes[0][:4]) \ and (first_bytes[8:12] == WebpFileTypeChecker.magic_bytes[0][8:12]) FILETYPE_CHECKERS = [ JpegFileTypeChecker, PngFileTypeChecker, TiffFileTypeChecker, WebpFileTypeChecker ] def check_file_type(file_path: str) -> Tuple[str, str]: with open(file_path, 'rb') as file: detection_byte_sequence = file.read( settings.GLAZE['FILETYPE_DETECTION_BYTE_SEQUENCE_LENGTH']) for checker in FILETYPE_CHECKERS: if checker.check(detection_byte_sequence): return checker.get_file_type() raise ValueError('Unsupported file type') for checker in FILETYPE_CHECKERS: Image.register_mime(checker.extension.upper(), checker.mime)
o32(image) + # size of bitmap o32(ppm[0]) + o32(ppm[1]) + # resolution o32(colors) + # colors used o32(colors)) # colors important fp.write(b"\0" * (header - 40)) # padding (for OS/2 format) if im.mode == "1": for i in (0, 255): fp.write(o8(i) * 4) elif im.mode == "L": for i in range(256): fp.write(o8(i) * 4) elif im.mode == "P": fp.write(im.im.getpalette("RGB", "BGRX")) 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")
fp.write(o16b(256)) for i in range(256): fp.write(o8(i)) if colormapmode == 'RGB': fp.write( o8(colormap[3 * i]) + o8(colormap[3 * i + 1]) + o8(colormap[3 * i + 2])) elif colormapmode == 'RGBA': fp.write( o8(colormap[4 * i]) + o8(colormap[4 * i + 1]) + o8(colormap[4 * i + 2])) # now convert data to raw form ImageFile._save( im, fp, [("raw", (0, 0)+im.size, 0, (rawmode, rowbytes, 1))]) if hasattr(fp, "flush"): fp.flush() # # -------------------------------------------------------------------- Image.register_save("Palm", _save) Image.register_extension("Palm", ".palm") Image.register_mime("Palm", "image/palm")
pass def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open("PNG", PngImageFile, _accept) Image.register_save("PNG", _save) Image.register_extension("PNG", ".png") Image.register_mime("PNG", "image/png")
## # Image plugin for MPEG streams. This plugin can identify a stream, # but it cannot read it. class MpegImageFile(ImageFile.ImageFile): format = "MPEG" format_description = "MPEG" def _open(self): s = BitStream(self.fp) if s.read(32) != 0x1B3: raise SyntaxError("not an MPEG file") self.mode = "RGB" self.size = s.read(12), s.read(12) # -------------------------------------------------------------------- # Registry stuff Image.register_open(MpegImageFile.format, MpegImageFile) Image.register_extension(MpegImageFile.format, ".mpg") Image.register_extension(MpegImageFile.format, ".mpeg") Image.register_mime(MpegImageFile.format, "video/mpeg")
+ o16(offset[1]) # offset + o16(im.size[0]) + o16(im.size[1]) # size + o8(0) + o8(8) # flags ) # bits ImageFile._save(im, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im.mode])]) fp.write(b"\0") # end of image data finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open(GifImageFile.format, GifImageFile, _accept) Image.register_save(GifImageFile.format, _save) Image.register_extension(GifImageFile.format, ".gif") Image.register_mime(GifImageFile.format, "image/gif") # # Uncomment the following line if you wish to use NETPBM/PBMPLUS # instead of the built-in "uncompressed" GIF encoder # Image.register_save(GifImageFile.format, _save_netpbm)
self.readonly = 1 def load_seek(self, pos): self.__fp.seek(pos) def seek(self, frame): if frame < 0 or frame >= self.__framecount: raise EOFError("no more images in MPO file") else: self.fp = self.__fp self.offset = self.__mpoffsets[frame] self.tile = [("jpeg", (0, 0) + self.size, self.offset, (self.mode, ""))] self.__frame = frame def tell(self): return self.__frame # -------------------------------------------------------------------q- # Registry stuff # Note that since MPO shares a factory with JPEG, we do not need to do a # separate registration for it here. #Image.register_open("MPO", JpegImagePlugin.jpeg_factory, _accept) Image.register_save("MPO", _save) Image.register_extension("MPO", ".mpo") Image.register_mime("MPO", "image/mpo")
tile_offset, tile_size, quality_mode, quality_layers, num_resolutions, cblk_size, precinct_size, irreversible, progression, cinema_mode, fd ) ImageFile._save(im, fp, [('jpeg2k', (0, 0)+im.size, 0, kind)]) # ------------------------------------------------------------ # Registry stuff Image.register_open('JPEG2000', Jpeg2KImageFile, _accept) Image.register_save('JPEG2000', _save) Image.register_extension('JPEG2000', '.jp2') Image.register_extension('JPEG2000', '.j2k') Image.register_extension('JPEG2000', '.jpc') Image.register_extension('JPEG2000', '.jpf') Image.register_extension('JPEG2000', '.jpx') Image.register_extension('JPEG2000', '.j2c') Image.register_mime('JPEG2000', 'image/jp2') Image.register_mime('JPEG2000', 'image/jpx')
if Image.DEBUG: print(cid, bytes, "(unknown)") s = self.fp.read(bytes) self.arg.crc(cid, s) self.fp.read(4) # ship extra CRC def tell(self): return 0 def verify(self): "Verify ARG file" # back up to first chunk self.fp.seek(8) self.arg.verify(self) self.arg.close() self.fp = None # # -------------------------------------------------------------------- Image.register_open("ARG", ArgImageFile, _accept) Image.register_extension("ARG", ".arg") Image.register_mime("ARG", "video/x-arg")
def jpeg_factory(fp=None, filename=None): im = JpegImageFile(fp, filename) try: mpheader = im._getmp() if mpheader[45057] > 1: # It's actually an MPO from .MpoImagePlugin import MpoImageFile im = MpoImageFile(fp, filename) except (TypeError, IndexError): # It is really a JPEG pass except SyntaxError: warnings.warn("Image appears to be a malformed MPO file, it will be " "interpreted as a base JPEG file") pass return im # -------------------------------------------------------------------q- # Registry stuff Image.register_open(JpegImageFile.format, jpeg_factory, _accept) Image.register_save(JpegImageFile.format, _save) Image.register_extension(JpegImageFile.format, ".jfif") Image.register_extension(JpegImageFile.format, ".jpe") Image.register_extension(JpegImageFile.format, ".jpg") Image.register_extension(JpegImageFile.format, ".jpeg") Image.register_mime(JpegImageFile.format, "image/jpeg")
(int(width * 72.0 / resolution), int(height * 72.0 / resolution))) xref[5] = fp.tell() _obj(fp, 5, Length=len(op.fp.getvalue())) fp.write("stream\n") fp.fp.write(op.fp.getvalue()) fp.write("\nendstream\n") _endobj(fp) # # trailer startxref = fp.tell() fp.write("xref\n0 %d\n0000000000 65535 f \n" % len(xref)) for x in xref[1:]: fp.write("%010d 00000 n \n" % x) fp.write("trailer\n<<\n/Size %d\n/Root 1 0 R\n>>\n" % len(xref)) fp.write("startxref\n%d\n%%%%EOF\n" % startxref) fp.flush() # # -------------------------------------------------------------------- Image.register_save("PDF", _save) Image.register_extension("PDF", ".pdf") Image.register_mime("PDF", "application/pdf")
ifd[PHOTOMETRIC_INTERPRETATION] = photo if im.mode == "P": lut = im.im.getpalette("RGB", "RGB;L") ifd[COLORMAP] = tuple(map(lambda v: ord(v) * 256, lut)) # data orientation stride = len(bits) * ((im.size[0] * bits[0] + 7) / 8) ifd[ROWSPERSTRIP] = im.size[1] ifd[STRIPBYTECOUNTS] = stride * im.size[1] ifd[STRIPOFFSETS] = 0 # this is adjusted by IFD writer ifd[COMPRESSION] = 1 # no compression offset = ifd.save(fp) ImageFile._save(im, fp, [("raw", (0, 0) + im.size, offset, (rawmode, stride, 1))]) # # -------------------------------------------------------------------- # Register Image.register_open("TIFF", TiffImageFile, _accept) Image.register_save("TIFF", _save) Image.register_extension("TIFF", ".tif") Image.register_extension("TIFF", ".tiff") Image.register_mime("TIFF", "image/tiff")
o32(0) + # compression (0=uncompressed) o32(image) + # size of bitmap o32(ppm[0]) + o32(ppm[1]) + # resolution o32(colors) + # colors used o32(colors)) # colors important fp.write(b"\0" * (header - 40)) # padding (for OS/2 format) if im.mode == "1": for i in (0, 255): fp.write(o8(i) * 4) elif im.mode == "L": for i in range(256): fp.write(o8(i) * 4) elif im.mode == "P": fp.write(im.im.getpalette("RGB", "BGRX")) 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")
self.mode = "P" self.palette = ImagePalette.raw("RGB", b"".join(palette)) self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))] def load_read(self, bytes): # # load all image data in one chunk xsize, ysize = self.size s = [None] * ysize for i in range(ysize): s[i] = self.fp.readline()[1:xsize + 1].ljust(xsize) self.fp = None return b"".join(s) # # Registry Image.register_open(XpmImageFile.format, XpmImageFile, _accept) Image.register_extension(XpmImageFile.format, ".xpm") Image.register_mime(XpmImageFile.format, "image/xpm")