home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / PIL / PsdImagePlugin.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  5.6 KB  |  226 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __version__ = '0.4'
  5. import string
  6. import Image
  7. import ImageFile
  8. import ImagePalette
  9. MODES = {
  10.     (0, 1): ('1', 1),
  11.     (0, 8): ('L', 1),
  12.     (1, 8): ('L', 1),
  13.     (2, 8): ('P', 1),
  14.     (3, 8): ('RGB', 3),
  15.     (4, 8): ('CMYK', 4),
  16.     (7, 8): ('L', 1),
  17.     (8, 8): ('L', 1),
  18.     (9, 8): ('LAB', 3) }
  19.  
  20. def i16(c):
  21.     return ord(c[1]) + (ord(c[0]) << 8)
  22.  
  23.  
  24. def i32(c):
  25.     return ord(c[3]) + (ord(c[2]) << 8) + (ord(c[1]) << 16) + (ord(c[0]) << 24)
  26.  
  27.  
  28. def _accept(prefix):
  29.     return prefix[:4] == '8BPS'
  30.  
  31.  
  32. class PsdImageFile(ImageFile.ImageFile):
  33.     format = 'PSD'
  34.     format_description = 'Adobe Photoshop'
  35.     
  36.     def _open(self):
  37.         read = self.fp.read
  38.         s = read(26)
  39.         if s[:4] != '8BPS' or i16(s[4:]) != 1:
  40.             raise SyntaxError, 'not a PSD file'
  41.         i16(s[4:]) != 1
  42.         psd_bits = i16(s[22:])
  43.         psd_channels = i16(s[12:])
  44.         psd_mode = i16(s[24:])
  45.         (mode, channels) = MODES[(psd_mode, psd_bits)]
  46.         if channels > psd_channels:
  47.             raise IOError, 'not enough channels'
  48.         channels > psd_channels
  49.         self.mode = mode
  50.         self.size = (i32(s[18:]), i32(s[14:]))
  51.         size = i32(read(4))
  52.         if size:
  53.             data = read(size)
  54.             if mode == 'P' and size == 768:
  55.                 self.palette = ImagePalette.raw('RGB;L', data)
  56.             
  57.         
  58.         self.resources = []
  59.         size = i32(read(4))
  60.         if size:
  61.             end = self.fp.tell() + size
  62.             while self.fp.tell() < end:
  63.                 signature = read(4)
  64.                 id = i16(read(2))
  65.                 name = read(ord(read(1)))
  66.                 if not len(name) & 1:
  67.                     read(1)
  68.                 
  69.                 data = read(i32(read(4)))
  70.                 if len(data) & 1:
  71.                     read(1)
  72.                 
  73.                 self.resources.append((id, name, data))
  74.         
  75.         self.layers = []
  76.         size = i32(read(4))
  77.         if size:
  78.             end = self.fp.tell() + size
  79.             size = i32(read(4))
  80.             if size:
  81.                 self.layers = _layerinfo(self.fp)
  82.             
  83.             self.fp.seek(end)
  84.         
  85.         self.tile = _maketile(self.fp, mode, (0, 0) + self.size, channels)
  86.         self._fp = self.fp
  87.         self.frame = 0
  88.  
  89.     
  90.     def seek(self, layer):
  91.         if layer == self.frame:
  92.             return None
  93.         
  94.         try:
  95.             if layer <= 0:
  96.                 raise IndexError
  97.             layer <= 0
  98.             (name, mode, bbox, tile) = self.layers[layer - 1]
  99.             self.mode = mode
  100.             self.tile = tile
  101.             self.frame = layer
  102.             self.fp = self._fp
  103.             return (name, bbox)
  104.         except IndexError:
  105.             layer == self.frame
  106.             layer == self.frame
  107.             raise EOFError, 'no such layer'
  108.         except:
  109.             layer == self.frame
  110.  
  111.  
  112.     
  113.     def tell(self):
  114.         return self.frame
  115.  
  116.     
  117.     def load_prepare(self):
  118.         if not (self.im) and self.im.mode != self.mode or self.im.size != self.size:
  119.             self.im = Image.core.fill(self.mode, self.size, 0)
  120.         
  121.         if self.mode == 'P':
  122.             Image.Image.load(self)
  123.         
  124.  
  125.  
  126.  
  127. def _layerinfo(file):
  128.     layers = []
  129.     read = file.read
  130.     for i in range(abs(i16(read(2)))):
  131.         y0 = i32(read(4))
  132.         x0 = i32(read(4))
  133.         y1 = i32(read(4))
  134.         x1 = i32(read(4))
  135.         info = []
  136.         mode = []
  137.         for i in range(i16(read(2))):
  138.             type = i16(read(2))
  139.             if type == 65535:
  140.                 m = 'A'
  141.             else:
  142.                 m = 'RGB'[type]
  143.             mode.append(m)
  144.             size = i32(read(4))
  145.             info.append((m, size))
  146.         
  147.         mode.sort()
  148.         if mode == [
  149.             'R']:
  150.             mode = 'L'
  151.         elif mode == [
  152.             'B',
  153.             'G',
  154.             'R']:
  155.             mode = 'RGB'
  156.         elif mode == [
  157.             'A',
  158.             'B',
  159.             'G',
  160.             'R']:
  161.             mode = 'RGBA'
  162.         else:
  163.             mode = None
  164.         filler = read(12)
  165.         name = None
  166.         file.seek(i32(read(4)), 1)
  167.         layers.append((name, mode, (x0, y0, x1, y1)))
  168.     
  169.     i = 0
  170.     for name, mode, bbox in layers:
  171.         tile = []
  172.         for m in mode:
  173.             t = _maketile(file, m, bbox, 1)
  174.             if t:
  175.                 tile.extend(t)
  176.                 continue
  177.         
  178.         layers[i] = (name, mode, bbox, tile)
  179.         i = i + 1
  180.     
  181.     return layers
  182.  
  183.  
  184. def _maketile(file, mode, bbox, channels):
  185.     tile = None
  186.     read = file.read
  187.     compression = i16(read(2))
  188.     xsize = bbox[2] - bbox[0]
  189.     ysize = bbox[3] - bbox[1]
  190.     offset = file.tell()
  191.     if compression == 0:
  192.         tile = []
  193.         for channel in range(channels):
  194.             layer = mode[channel]
  195.             if mode == 'CMYK':
  196.                 layer = layer + ';I'
  197.             
  198.             tile.append(('raw', bbox, offset, layer))
  199.             offset = offset + xsize * ysize
  200.         
  201.     elif compression == 1:
  202.         i = 0
  203.         tile = []
  204.         bytecount = read(channels * ysize * 2)
  205.         offset = file.tell()
  206.         for channel in range(channels):
  207.             layer = mode[channel]
  208.             if mode == 'CMYK':
  209.                 layer = layer + ';I'
  210.             
  211.             tile.append(('packbits', bbox, offset, layer))
  212.             for y in range(ysize):
  213.                 offset = offset + i16(bytecount[i:i + 2])
  214.                 i = i + 2
  215.             
  216.         
  217.     
  218.     file.seek(offset)
  219.     if offset & 1:
  220.         read(1)
  221.     
  222.     return tile
  223.  
  224. Image.register_open('PSD', PsdImageFile, _accept)
  225. Image.register_extension('PSD', '.psd')
  226.