home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pypil112.zip / PIL-1.1.2.zip / Lib / site-packages / PIL / ImageFile.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2001-12-25  |  11KB  |  341 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.2)
  3.  
  4. import Image
  5. import traceback
  6. import sys
  7. MAXBLOCK = 65536
  8. MAPMODES = ('L', 'P', 'RGBX', 'RGBA', 'CMYK', 'I;16', 'I;16B')
  9.  
  10. def _tilesort(t1, t2):
  11.     return cmp(t1[2], t2[2])
  12.  
  13.  
  14. class ImageFile(Image.Image):
  15.     '''Base class for image file format handlers.'''
  16.     
  17.     def __init__(self, fp = None, filename = None):
  18.         Image.Image.__init__(self)
  19.         self.tile = None
  20.         self.readonly = 1
  21.         self.decoderconfig = ()
  22.         self.decodermaxblock = MAXBLOCK
  23.         if type(fp) == type(''):
  24.             self.fp = open(fp, 'rb')
  25.             self.filename = fp
  26.         else:
  27.             self.fp = fp
  28.             self.filename = filename
  29.         
  30.         try:
  31.             self._open()
  32.         except IndexError:
  33.             v = None
  34.             if Image.DEBUG > 1:
  35.                 traceback.print_exc()
  36.             
  37.             raise SyntaxError, v
  38.         except TypeError:
  39.             v = None
  40.             if Image.DEBUG > 1:
  41.                 traceback.print_exc()
  42.             
  43.             raise SyntaxError, v
  44.         except KeyError:
  45.             v = None
  46.             if Image.DEBUG > 1:
  47.                 traceback.print_exc()
  48.             
  49.             raise SyntaxError, v
  50.  
  51.         if not (self.mode) or self.size[0] <= 0:
  52.             raise SyntaxError, 'not identified by this driver'
  53.         
  54.  
  55.     
  56.     def draft(self, mode, size):
  57.         '''Set draft mode'''
  58.         pass
  59.  
  60.     
  61.     def verify(self):
  62.         '''Check file integrity'''
  63.         self.fp = None
  64.  
  65.     
  66.     def load(self):
  67.         '''Load image data based on tile list'''
  68.         Image.Image.load(self)
  69.         if self.tile is None:
  70.             raise IOError, 'cannot load this image'
  71.         
  72.         if not (self.tile):
  73.             return None
  74.         
  75.         self.map = None
  76.         readonly = 0
  77.         if self.filename and len(self.tile) == 1:
  78.             (d, e, o, a) = self.tile[0]
  79.             if d == 'raw' and a[0] == self.mode and a[0] in MAPMODES:
  80.                 
  81.                 try:
  82.                     self.map = Image.core.map(self.filename)
  83.                     self.map.seek(o)
  84.                     self.im = self.map.readimage(self.mode, self.size, a[1], a[2])
  85.                     readonly = 1
  86.                 except (AttributeError, IOError):
  87.                     self.map = None
  88.  
  89.             
  90.         
  91.         self.load_prepare()
  92.         if not (self.map):
  93.             self.tile.sort(_tilesort)
  94.             
  95.             try:
  96.                 prefix = self.tile_prefix
  97.             except AttributeError:
  98.                 prefix = ''
  99.  
  100.             for d, e, o, a in self.tile:
  101.                 d = Image._getdecoder(self.mode, d, a, self.decoderconfig)
  102.                 self.load_seek(o)
  103.                 
  104.                 try:
  105.                     d.setimage(self.im, e)
  106.                 except ValueError:
  107.                     continue
  108.  
  109.                 b = prefix
  110.                 t = len(b)
  111.                 while 1:
  112.                     s = self.load_read(self.decodermaxblock)
  113.                     if not s:
  114.                         self.tile = []
  115.                         raise IOError, 'image file is truncated, %d bytes left in buffer' % len(b)
  116.                     
  117.                     b = b + s
  118.                     (n, e) = d.decode(b)
  119.                     if n < 0:
  120.                         break
  121.                     
  122.                     b = b[n:]
  123.                     t = t + n
  124.             
  125.         
  126.         self.tile = []
  127.         self.readonly = readonly
  128.         self.fp = None
  129.         if not (self.map) and e < 0:
  130.             raise IOError, 'decoder error %d when reading image file' % e
  131.         
  132.         if hasattr(self, 'tile_post_rotate'):
  133.             self.im = self.im.rotate(self.tile_post_rotate)
  134.             self.size = self.im.size
  135.         
  136.         self.load_end()
  137.  
  138.     
  139.     def load_prepare(self):
  140.         if not (self.im) and self.im.mode != self.mode or self.im.size != self.size:
  141.             self.im = Image.core.new(self.mode, self.size)
  142.         
  143.         if self.mode == 'P':
  144.             Image.Image.load(self)
  145.         
  146.  
  147.     
  148.     def load_end(self):
  149.         pass
  150.  
  151.     
  152.     def load_seek(self, pos):
  153.         self.fp.seek(pos)
  154.  
  155.     
  156.     def load_read(self, bytes):
  157.         return self.fp.read(bytes)
  158.  
  159.  
  160.  
  161. class _ParserFile:
  162.     
  163.     def __init__(self, data):
  164.         self.data = data
  165.         self.offset = 0
  166.  
  167.     
  168.     def close(self):
  169.         self.data = self.offset = None
  170.  
  171.     
  172.     def tell(self):
  173.         return self.offset
  174.  
  175.     
  176.     def seek(self, offset, whence = 0):
  177.         if whence == 0:
  178.             self.offset = offset
  179.         elif whence == 1:
  180.             self.offset = self.offset + offset
  181.         else:
  182.             raise IOError, 'illegal argument to seek'
  183.  
  184.     
  185.     def read(self, bytes = 0):
  186.         pos = self.offset
  187.         if bytes:
  188.             data = self.data[pos:pos + bytes]
  189.         else:
  190.             data = self.data[pos:]
  191.         self.offset = pos + len(data)
  192.         return data
  193.  
  194.     
  195.     def readline(self):
  196.         s = ''
  197.         while 1:
  198.             c = self.read(1)
  199.             if not c:
  200.                 break
  201.             
  202.             s = s + c
  203.             if c == '\n':
  204.                 break
  205.             
  206.         return s
  207.  
  208.  
  209.  
  210. class Parser:
  211.     image = None
  212.     data = None
  213.     decoder = None
  214.     finished = 0
  215.     
  216.     def reset(self):
  217.         if not __debug__ and self.data is None:
  218.             raise AssertionError, 'cannot reuse parsers'
  219.  
  220.     
  221.     def feed(self, data):
  222.         if self.finished:
  223.             return None
  224.         
  225.         if self.data is None:
  226.             self.data = data
  227.         else:
  228.             self.data = self.data + data
  229.         if self.decoder:
  230.             if self.offset > 0:
  231.                 skip = min(len(self.data), self.offset)
  232.                 self.data = self.data[skip:]
  233.                 self.offset = self.offset - skip
  234.                 if self.offset > 0 or not (self.data):
  235.                     return None
  236.                 
  237.             
  238.             (n, e) = self.decoder.decode(self.data)
  239.             if n < 0:
  240.                 self.data = None
  241.                 self.finished = 1
  242.                 if e < 0:
  243.                     self.image = None
  244.                     raise IOError, 'decoder error %d when reading image file' % e
  245.                 else:
  246.                     return None
  247.             
  248.             self.data = self.data[n:]
  249.         else:
  250.             
  251.             try:
  252.                 
  253.                 try:
  254.                     fp = _ParserFile(self.data)
  255.                     im = Image.open(fp)
  256.                 finally:
  257.                     fp.close()
  258.  
  259.             except IOError:
  260.                 pass
  261.  
  262.             if len(im.tile) != 1:
  263.                 raise IOError, 'cannot parse this image'
  264.             
  265.             im.load_prepare()
  266.             (d, e, o, a) = im.tile[0]
  267.             im.tile = []
  268.             self.decoder = Image._getdecoder(im.mode, d, a, im.decoderconfig)
  269.             self.decoder.setimage(im.im, e)
  270.             self.offset = o
  271.             if self.offset <= len(self.data):
  272.                 self.data = self.data[self.offset:]
  273.                 self.offset = 0
  274.             
  275.             self.image = im
  276.  
  277.     
  278.     def close(self):
  279.         if self.decoder:
  280.             self.feed('')
  281.             self.data = self.decoder = None
  282.             if not (self.finished):
  283.                 raise IOError, 'image was incomplete'
  284.             
  285.         
  286.         if not (self.image):
  287.             raise IOError, 'cannot parse this image'
  288.         
  289.         return self.image
  290.  
  291.  
  292.  
  293. def _save(im, fp, tile):
  294.     '''Helper to save image based on tile list'''
  295.     im.load()
  296.     if not hasattr(im, 'encoderconfig'):
  297.         im.encoderconfig = ()
  298.     
  299.     tile.sort(_tilesort)
  300.     bufsize = max(MAXBLOCK, im.size[0] * 4)
  301.     
  302.     try:
  303.         fh = fp.fileno()
  304.         fp.flush()
  305.     except AttributeError:
  306.         for e, b, o, a in tile:
  307.             e = Image._getencoder(im.mode, e, a, im.encoderconfig)
  308.             if o > 0:
  309.                 fp.seek(o, 0)
  310.             
  311.             e.setimage(im.im, b)
  312.             while 1:
  313.                 (l, s, d) = e.encode(bufsize)
  314.                 fp.write(d)
  315.                 if s:
  316.                     break
  317.                 
  318.             if s < 0:
  319.                 raise IOError, 'encoder error %d when writing image file' % s
  320.             
  321.         
  322.  
  323.     for e, b, o, a in tile:
  324.         e = Image._getencoder(im.mode, e, a, im.encoderconfig)
  325.         if o > 0:
  326.             fp.seek(o, 0)
  327.         
  328.         e.setimage(im.im, b)
  329.         s = e.encode_to_file(fh, bufsize)
  330.         if s < 0:
  331.             raise IOError, 'encoder error %d when writing image file' % s
  332.         
  333.     
  334.     
  335.     try:
  336.         fp.flush()
  337.     except:
  338.         pass
  339.  
  340.  
  341.