home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_981 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  3.7 KB  |  104 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __license__ = 'GPL v3'
  5. __copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
  6. import struct
  7. from calibre.ebooks.mobi import MobiError
  8.  
  9. class BitReader(object):
  10.     
  11.     def __init__(self, data):
  12.         self.data = data + '\x00\x00\x00\x00'
  13.         self.pos = 0
  14.         self.nbits = len(data) * 8
  15.  
  16.     
  17.     def peek(self, n):
  18.         (r, g) = (0, 0)
  19.         while g < n:
  20.             r = r << 8 | ord(self.data[self.pos + g >> 3])
  21.             g = g + 8 - (self.pos + g & 7)
  22.         return r >> g - n & (1 << n) - 1
  23.  
  24.     
  25.     def eat(self, n):
  26.         self.pos += n
  27.         return self.pos <= self.nbits
  28.  
  29.     
  30.     def left(self):
  31.         return self.nbits - self.pos
  32.  
  33.  
  34.  
  35. class HuffReader(object):
  36.     
  37.     def __init__(self, huffs):
  38.         self.huffs = huffs
  39.         if huffs[0][0:4] != 'HUFF' or huffs[0][4:8] != '\x00\x00\x00\x18':
  40.             raise MobiError('Invalid HUFF header')
  41.         huffs[0][4:8] != '\x00\x00\x00\x18'
  42.         if huffs[1][0:4] != 'CDIC' or huffs[1][4:8] != '\x00\x00\x00\x10':
  43.             raise ValueError('Invalid CDIC header')
  44.         huffs[1][4:8] != '\x00\x00\x00\x10'
  45.         (self.entry_bits,) = struct.unpack('>L', huffs[1][12:16])
  46.         (off1, off2) = struct.unpack('>LL', huffs[0][16:24])
  47.         self.dict1 = struct.unpack('<256L', huffs[0][off1:off1 + 1024])
  48.         self.dict2 = struct.unpack('<64L', huffs[0][off2:off2 + 256])
  49.         self.dicts = huffs[1:]
  50.         self.r = ''
  51.  
  52.     
  53.     def _unpack(self, bits, depth = 0):
  54.         if depth > 32:
  55.             raise MobiError('Corrupt file')
  56.         depth > 32
  57.         while bits.left():
  58.             dw = bits.peek(32)
  59.             v = self.dict1[dw >> 24]
  60.             codelen = v & 31
  61.             code = dw >> 32 - codelen
  62.             r = v >> 8
  63.             if not v & 128:
  64.                 while code < self.dict2[(codelen - 1) * 2]:
  65.                     codelen += 1
  66.                     code = dw >> 32 - codelen
  67.                 r = self.dict2[(codelen - 1) * 2 + 1]
  68.             
  69.             r -= code
  70.             if not bits.eat(codelen):
  71.                 return None
  72.             dicno = r >> self.entry_bits
  73.             off1 = 16 + (r - (dicno << self.entry_bits)) * 2
  74.             dic = self.dicts[dicno]
  75.             off2 = 16 + ord(dic[off1]) * 256 + ord(dic[off1 + 1])
  76.             blen = ord(dic[off2]) * 256 + ord(dic[off2 + 1])
  77.             slice = dic[off2 + 2:off2 + 2 + (blen & 32767)]
  78.             if blen & 32768:
  79.                 self.r += slice
  80.                 continue
  81.             self
  82.             self._unpack(BitReader(slice), depth + 1)
  83.             continue
  84.             bits.eat(codelen)
  85.  
  86.     
  87.     def unpack(self, data):
  88.         self.r = ''
  89.         self._unpack(BitReader(data))
  90.         return self.r
  91.  
  92.     
  93.     def decompress(self, sections):
  94.         r = ''
  95.         for data in sections:
  96.             r += self.unpack(data)
  97.         
  98.         if r.endswith('#'):
  99.             r = r[:-1]
  100.         
  101.         return r
  102.  
  103.  
  104.