Server IP : 85.214.239.14 / Your IP : 3.147.86.30 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /srv/modoboa/env/lib/python3.5/site-packages/PIL/ |
Upload File : |
# # THIS IS WORK IN PROGRESS # # The Python Imaging Library. # $Id$ # # FlashPix support for PIL # # History: # 97-01-25 fl Created (reads uncompressed RGB images only) # # Copyright (c) Secret Labs AB 1997. # Copyright (c) Fredrik Lundh 1997. # # See the README file for information on usage and redistribution. # import olefile from . import Image, ImageFile from ._binary import i8, i32le as i32 # we map from colour field tuples to (mode, rawmode) descriptors MODES = { # opacity (0x00007FFE): ("A", "L"), # monochrome (0x00010000,): ("L", "L"), (0x00018000, 0x00017FFE): ("RGBA", "LA"), # photo YCC (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"), (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"), # standard RGB (NIFRGB) (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"), (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"), } # # -------------------------------------------------------------------- def _accept(prefix): return prefix[:8] == olefile.MAGIC ## # Image plugin for the FlashPix images. class FpxImageFile(ImageFile.ImageFile): format = "FPX" format_description = "FlashPix" def _open(self): # # read the OLE directory and see if this is a likely # to be a FlashPix file try: self.ole = olefile.OleFileIO(self.fp) except OSError: raise SyntaxError("not an FPX file; invalid OLE file") if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B": raise SyntaxError("not an FPX file; bad root CLSID") self._open_index(1) def _open_index(self, index=1): # # get the Image Contents Property Set prop = self.ole.getproperties( ["Data Object Store %06d" % index, "\005Image Contents"] ) # size (highest resolution) self._size = prop[0x1000002], prop[0x1000003] size = max(self.size) i = 1 while size > 64: size = size / 2 i += 1 self.maxid = i - 1 # mode. instead of using a single field for this, flashpix # requires you to specify the mode for each channel in each # resolution subimage, and leaves it to the decoder to make # sure that they all match. for now, we'll cheat and assume # that this is always the case. id = self.maxid << 16 s = prop[0x2000002 | id] colors = [] bands = i32(s, 4) if bands > 4: raise IOError("Invalid number of bands") for i in range(bands): # note: for now, we ignore the "uncalibrated" flag colors.append(i32(s, 8 + i * 4) & 0x7FFFFFFF) self.mode, self.rawmode = MODES[tuple(colors)] # load JPEG tables, if any self.jpeg = {} for i in range(256): id = 0x3000001 | (i << 16) if id in prop: self.jpeg[i] = prop[id] self._open_subimage(1, self.maxid) def _open_subimage(self, index=1, subimage=0): # # setup tile descriptors for a given subimage stream = [ "Data Object Store %06d" % index, "Resolution %04d" % subimage, "Subimage 0000 Header", ] fp = self.ole.openstream(stream) # skip prefix fp.read(28) # header stream s = fp.read(36) size = i32(s, 4), i32(s, 8) # tilecount = i32(s, 12) tilesize = i32(s, 16), i32(s, 20) # channels = i32(s, 24) offset = i32(s, 28) length = i32(s, 32) if size != self.size: raise OSError("subimage mismatch") # get tile descriptors fp.seek(28 + offset) s = fp.read(i32(s, 12) * length) x = y = 0 xsize, ysize = size xtile, ytile = tilesize self.tile = [] for i in range(0, len(s), length): compression = i32(s, i + 8) if compression == 0: self.tile.append( ( "raw", (x, y, x + xtile, y + ytile), i32(s, i) + 28, (self.rawmode), ) ) elif compression == 1: # FIXME: the fill decoder is not implemented self.tile.append( ( "fill", (x, y, x + xtile, y + ytile), i32(s, i) + 28, (self.rawmode, s[12:16]), ) ) elif compression == 2: internal_color_conversion = i8(s[14]) jpeg_tables = i8(s[15]) rawmode = self.rawmode if internal_color_conversion: # The image is stored as usual (usually YCbCr). if rawmode == "RGBA": # For "RGBA", data is stored as YCbCrA based on # negative RGB. The following trick works around # this problem : jpegmode, rawmode = "YCbCrK", "CMYK" else: jpegmode = None # let the decoder decide else: # The image is stored as defined by rawmode jpegmode = rawmode self.tile.append( ( "jpeg", (x, y, x + xtile, y + ytile), i32(s, i) + 28, (rawmode, jpegmode), ) ) # FIXME: jpeg tables are tile dependent; the prefix # data must be placed in the tile descriptor itself! if jpeg_tables: self.tile_prefix = self.jpeg[jpeg_tables] else: raise OSError("unknown/invalid compression") x = x + xtile if x >= xsize: x, y = 0, y + ytile if y >= ysize: break # isn't really required self.stream = stream self.fp = None def load(self): if not self.fp: self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"]) return ImageFile.ImageFile.load(self) # # -------------------------------------------------------------------- Image.register_open(FpxImageFile.format, FpxImageFile, _accept) Image.register_extension(FpxImageFile.format, ".fpx")