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 / ArgImagePlugin.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2001-12-25  |  18KB  |  453 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.2)
  3.  
  4. __version__ = '0.3'
  5. import marshal
  6. import rexec
  7. import string
  8. import Image
  9. import ImageFile
  10. import ImagePalette
  11. from PngImagePlugin import i16, i32, ChunkStream, _MODES
  12. MAGIC = '\x8aARG\r\n\x1a\n'
  13. APPLET_HOOK = None
  14.  
  15. class ArgStream(ChunkStream):
  16.     '''Parser callbacks for ARG data'''
  17.     
  18.     def __init__(self, fp):
  19.         ChunkStream.__init__(self, fp)
  20.         self.eof = 0
  21.         self.im = None
  22.         self.palette = None
  23.         self._ArgStream__reset()
  24.  
  25.     
  26.     def __reset(self):
  27.         self.count = 0
  28.         self.id = None
  29.         self.action = ('NONE',)
  30.         self.images = { }
  31.         self.names = { }
  32.         self.applets = { }
  33.  
  34.     
  35.     def chunk_AHDR(self, offset, bytes):
  36.         '''AHDR -- animation header'''
  37.         if self.count != 0:
  38.             raise SyntaxError, 'misplaced AHDR chunk'
  39.         
  40.         s = self.fp.read(bytes)
  41.         self.size = (i32(s), i32(s[4:]))
  42.         
  43.         try:
  44.             (self.mode, self.rawmode) = _MODES[(ord(s[8]), ord(s[9]))]
  45.         except:
  46.             raise SyntaxError, 'unknown ARG mode'
  47.  
  48.         if Image.DEBUG:
  49.             print 'AHDR size', self.size
  50.             print 'AHDR mode', self.mode, self.rawmode
  51.         
  52.         return s
  53.  
  54.     
  55.     def chunk_AFRM(self, offset, bytes):
  56.         '''AFRM -- next frame follows'''
  57.         if self.count != 0:
  58.             raise SyntaxError, 'misplaced AFRM chunk'
  59.         
  60.         self.show = 1
  61.         self.id = 0
  62.         self.count = 1
  63.         self.repair = None
  64.         s = self.fp.read(bytes)
  65.         if len(s) >= 2:
  66.             self.id = i16(s)
  67.             if len(s) >= 4:
  68.                 self.count = i16(s[2:4])
  69.                 if len(s) >= 6:
  70.                     self.repair = i16(s[4:6])
  71.                 else:
  72.                     self.repair = None
  73.             
  74.         
  75.         if Image.DEBUG:
  76.             print 'AFRM', self.id, self.count
  77.         
  78.         return s
  79.  
  80.     
  81.     def chunk_ADEF(self, offset, bytes):
  82.         '''ADEF -- store image'''
  83.         if self.count != 0:
  84.             raise SyntaxError, 'misplaced ADEF chunk'
  85.         
  86.         self.show = 0
  87.         self.id = 0
  88.         self.count = 1
  89.         self.repair = None
  90.         s = self.fp.read(bytes)
  91.         if len(s) >= 2:
  92.             self.id = i16(s)
  93.             if len(s) >= 4:
  94.                 self.count = i16(s[2:4])
  95.             
  96.         
  97.         if Image.DEBUG:
  98.             print 'ADEF', self.id, self.count
  99.         
  100.         return s
  101.  
  102.     
  103.     def chunk_NAME(self, offset, bytes):
  104.         '''NAME -- name the current image'''
  105.         if self.count == 0:
  106.             raise SyntaxError, 'misplaced NAME chunk'
  107.         
  108.         name = self.fp.read(bytes)
  109.         self.names[self.id] = name
  110.         return name
  111.  
  112.     
  113.     def chunk_AEND(self, offset, bytes):
  114.         '''AEND -- end of animation'''
  115.         if Image.DEBUG:
  116.             print 'AEND'
  117.         
  118.         self.eof = 1
  119.         raise EOFError, 'end of ARG file'
  120.  
  121.     
  122.     def __getmodesize(self, s, full = 1):
  123.         size = (i32(s), i32(s[4:]))
  124.         
  125.         try:
  126.             (mode, rawmode) = _MODES[(ord(s[8]), ord(s[9]))]
  127.         except:
  128.             raise SyntaxError, 'unknown image mode'
  129.  
  130.         if full:
  131.             if ord(s[12]):
  132.                 pass
  133.             
  134.             if ord(s[11]):
  135.                 raise SyntaxError, 'unknown filter category'
  136.             
  137.         
  138.         return (size, mode, rawmode)
  139.  
  140.     
  141.     def chunk_PAST(self, offset, bytes):
  142.         '''PAST -- paste one image into another'''
  143.         if self.count == 0:
  144.             raise SyntaxError, 'misplaced PAST chunk'
  145.         
  146.         if self.repair is not None:
  147.             self.images[self.id] = self.images[self.repair].copy()
  148.             self.repair = None
  149.         
  150.         s = self.fp.read(bytes)
  151.         im = self.images[i16(s)]
  152.         (x, y) = (i32(s[2:6]), i32(s[6:10]))
  153.         bbox = (x, y, im.size[0] + x, im.size[1] + y)
  154.         if im.mode in [
  155.             'RGBA']:
  156.             self.images[self.id].paste(im, bbox, im)
  157.         else:
  158.             self.images[self.id].paste(im, bbox)
  159.         self.action = ('PAST',)
  160.         self._ArgStream__store()
  161.         return s
  162.  
  163.     
  164.     def chunk_BLNK(self, offset, bytes):
  165.         '''BLNK -- create blank image'''
  166.         if self.count == 0:
  167.             raise SyntaxError, 'misplaced BLNK chunk'
  168.         
  169.         s = self.fp.read(bytes)
  170.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  171.         self.action = ('BLNK',)
  172.         self.im = Image.core.fill(mode, size, 0)
  173.         self._ArgStream__store()
  174.         return s
  175.  
  176.     
  177.     def chunk_IHDR(self, offset, bytes):
  178.         '''IHDR -- full image follows'''
  179.         if self.count == 0:
  180.             raise SyntaxError, 'misplaced IHDR chunk'
  181.         
  182.         s = self.fp.read(bytes)
  183.         (size, mode, rawmode) = self._ArgStream__getmodesize(s)
  184.         self.action = ('IHDR',)
  185.         self.im = Image.core.new(mode, size)
  186.         self.decoder = Image.core.zip_decoder(rawmode)
  187.         self.decoder.setimage(self.im, (0, 0) + size)
  188.         self.data = ''
  189.         return s
  190.  
  191.     
  192.     def chunk_DHDR(self, offset, bytes):
  193.         '''DHDR -- delta image follows'''
  194.         if self.count == 0:
  195.             raise SyntaxError, 'misplaced DHDR chunk'
  196.         
  197.         s = self.fp.read(bytes)
  198.         (size, mode, rawmode) = self._ArgStream__getmodesize(s)
  199.         diff = ord(s[13])
  200.         offs = (i32(s[14:18]), i32(s[18:22]))
  201.         bbox = offs + (offs[0] + size[0], offs[1] + size[1])
  202.         if Image.DEBUG:
  203.             print 'DHDR', diff, bbox
  204.         
  205.         self.action = ('DHDR', diff, bbox)
  206.         self.im = Image.core.new(mode, size)
  207.         self.decoder = Image.core.zip_decoder(rawmode)
  208.         self.decoder.setimage(self.im, (0, 0) + size)
  209.         self.data = ''
  210.         return s
  211.  
  212.     
  213.     def chunk_JHDR(self, offset, bytes):
  214.         '''JHDR -- JPEG image follows'''
  215.         if self.count == 0:
  216.             raise SyntaxError, 'misplaced JHDR chunk'
  217.         
  218.         s = self.fp.read(bytes)
  219.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  220.         self.action = ('JHDR',)
  221.         self.im = Image.core.new(mode, size)
  222.         self.decoder = Image.core.jpeg_decoder(rawmode)
  223.         self.decoder.setimage(self.im, (0, 0) + size)
  224.         self.data = ''
  225.         return s
  226.  
  227.     
  228.     def chunk_UHDR(self, offset, bytes):
  229.         '''UHDR -- uncompressed image data follows (EXPERIMENTAL)'''
  230.         if self.count == 0:
  231.             raise SyntaxError, 'misplaced UHDR chunk'
  232.         
  233.         s = self.fp.read(bytes)
  234.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  235.         self.action = ('UHDR',)
  236.         self.im = Image.core.new(mode, size)
  237.         self.decoder = Image.core.raw_decoder(rawmode)
  238.         self.decoder.setimage(self.im, (0, 0) + size)
  239.         self.data = ''
  240.         return s
  241.  
  242.     
  243.     def chunk_IDAT(self, offset, bytes):
  244.         '''IDAT -- image data block'''
  245.         s = self.fp.read(bytes)
  246.         self.data = self.data + s
  247.         (n, e) = self.decoder.decode(self.data)
  248.         if n < 0:
  249.             if e < 0:
  250.                 raise IOError, 'decoder error %d' % e
  251.             
  252.         else:
  253.             self.data = self.data[n:]
  254.         return s
  255.  
  256.     
  257.     def chunk_DEND(self, offset, bytes):
  258.         return self.chunk_IEND(offset, bytes)
  259.  
  260.     
  261.     def chunk_JEND(self, offset, bytes):
  262.         return self.chunk_IEND(offset, bytes)
  263.  
  264.     
  265.     def chunk_UEND(self, offset, bytes):
  266.         return self.chunk_IEND(offset, bytes)
  267.  
  268.     
  269.     def chunk_IEND(self, offset, bytes):
  270.         '''IEND -- end of image'''
  271.         del self.decoder
  272.         del self.data
  273.         self._ArgStream__store()
  274.         return self.fp.read(bytes)
  275.  
  276.     
  277.     def __store(self):
  278.         cid = self.action[0]
  279.         if cid in [
  280.             'BLNK',
  281.             'IHDR',
  282.             'JHDR',
  283.             'UHDR']:
  284.             self.images[self.id] = self.im
  285.         elif cid == 'DHDR':
  286.             (cid, mode, bbox) = self.action
  287.             im0 = self.images[self.id]
  288.             im1 = self.im
  289.             if mode == 0:
  290.                 im1 = im1.chop_add_modulo(im0.crop(bbox))
  291.             
  292.             im0.paste(im1, bbox)
  293.         
  294.         self.count = self.count - 1
  295.         if self.count == 0 and self.show:
  296.             self.im = self.images[self.id]
  297.             raise EOFError
  298.         
  299.  
  300.     
  301.     def chunk_PLTE(self, offset, bytes):
  302.         '''PLTE -- palette data'''
  303.         s = self.fp.read(bytes)
  304.         if self.mode == 'P':
  305.             self.palette = ImagePalette.raw('RGB', s)
  306.         
  307.         return s
  308.  
  309.     
  310.     def chunk_sYNC(self, offset, bytes):
  311.         '''SYNC -- reset decoder'''
  312.         if self.count != 0:
  313.             raise SyntaxError, 'misplaced sYNC chunk'
  314.         
  315.         s = self.fp.read(bytes)
  316.         self._ArgStream__reset()
  317.         return s
  318.  
  319.     
  320.     def chunk_aAPP(self, offset, bytes):
  321.         '''aAPP -- store application'''
  322.         s = self.fp.read(bytes)
  323.         j = string.find(s, '\x00')
  324.         name = s[:j]
  325.         i = j + 1
  326.         j = string.find(s, '\x00', i)
  327.         type = s[i:j]
  328.         code = s[j + 1:]
  329.         if Image.DEBUG:
  330.             print 'AAPP', repr(type), repr(name)
  331.         
  332.         if not code:
  333.             if self.applets.has_key(name):
  334.                 del self.applets[name]
  335.             
  336.         elif type != 'python':
  337.             raise IOError, 'unsupported script type ' + type
  338.         
  339.         code = marshal.loads(code)
  340.         if not name:
  341.             self._ArgStream__applet(code)
  342.         else:
  343.             
  344.             try:
  345.                 self.applets[name] = marshal.loads(code)
  346.             except:
  347.                 pass
  348.  
  349.         return s
  350.  
  351.     
  352.     def chunk_aRUN(self, offset, bytes):
  353.         '''aRUN -- execute application'''
  354.         s = self.fp.read(bytes)
  355.         j = string.find(s, '\x00')
  356.         name = s[:j]
  357.         print 'ARUN', name
  358.         self._ArgStream__applet(self.applets[name])
  359.         return s
  360.  
  361.     
  362.     def __applet(self, code):
  363.         if not APPLET_HOOK:
  364.             return None
  365.         
  366.         safe = rexec.RExec()
  367.         safe.r_exec(code)
  368.         images = { }
  369.         for id, im in self.images.items():
  370.             i = Image.new(im.mode, im.size)
  371.             i.im = im
  372.             images[id] = i
  373.             if self.names.has_key(id):
  374.                 images[self.names[id]] = i
  375.             
  376.         
  377.         APPLET_HOOK(safe.modules['__main__'].Animation, images)
  378.  
  379.  
  380.  
  381. def _accept(prefix):
  382.     return prefix[:8] == MAGIC
  383.  
  384.  
  385. class ArgImageFile(ImageFile.ImageFile):
  386.     format = 'ARG'
  387.     format_description = 'Animated raster graphics'
  388.     
  389.     def _open(self):
  390.         if self.fp.read(8) != MAGIC:
  391.             raise SyntaxError, 'not an ARG file'
  392.         
  393.         self.arg = ArgStream(self.fp)
  394.         (cid, offset, bytes) = self.arg.read()
  395.         if cid != 'AHDR':
  396.             raise SyntaxError, 'expected an AHDR chunk'
  397.         
  398.         s = self.arg.call(cid, offset, bytes)
  399.         self.arg.crc(cid, s)
  400.         self.mode = self.arg.mode
  401.         self.size = self.arg.size
  402.  
  403.     
  404.     def load(self):
  405.         if self.arg.im is None:
  406.             self.seek(0)
  407.         
  408.         self.im = self.arg.im
  409.         self.palette = self.arg.palette
  410.         Image.Image.load(self)
  411.  
  412.     
  413.     def seek(self, frame):
  414.         if self.arg.eof:
  415.             raise EOFError, 'end of animation'
  416.         
  417.         self.fp = self.arg.fp
  418.         while 1:
  419.             (cid, offset, bytes) = self.arg.read()
  420.             if self.arg.eof:
  421.                 raise EOFError, 'end of animation'
  422.             
  423.             
  424.             try:
  425.                 s = self.arg.call(cid, offset, bytes)
  426.             except EOFError:
  427.                 break
  428.             except 'glurk':
  429.                 if Image.DEBUG:
  430.                     print cid, bytes, '(unknown)'
  431.                 
  432.                 s = self.fp.read(bytes)
  433.  
  434.             self.arg.crc(cid, s)
  435.         self.fp.read(4)
  436.  
  437.     
  438.     def tell(self):
  439.         return 0
  440.  
  441.     
  442.     def verify(self):
  443.         '''Verify ARG file'''
  444.         self.fp.seek(8)
  445.         self.arg.verify(self)
  446.         self.arg.close()
  447.         self.fp = None
  448.  
  449.  
  450. Image.register_open('ARG', ArgImageFile, _accept)
  451. Image.register_extension('ARG', '.arg')
  452. Image.register_mime('ARG', 'video/x-arg')
  453.