home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2811 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  12.2 KB  |  438 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. AUDIO_FILE_MAGIC = 779316836
  5. AUDIO_FILE_ENCODING_MULAW_8 = 1
  6. AUDIO_FILE_ENCODING_LINEAR_8 = 2
  7. AUDIO_FILE_ENCODING_LINEAR_16 = 3
  8. AUDIO_FILE_ENCODING_LINEAR_24 = 4
  9. AUDIO_FILE_ENCODING_LINEAR_32 = 5
  10. AUDIO_FILE_ENCODING_FLOAT = 6
  11. AUDIO_FILE_ENCODING_DOUBLE = 7
  12. AUDIO_FILE_ENCODING_ADPCM_G721 = 23
  13. AUDIO_FILE_ENCODING_ADPCM_G722 = 24
  14. AUDIO_FILE_ENCODING_ADPCM_G723_3 = 25
  15. AUDIO_FILE_ENCODING_ADPCM_G723_5 = 26
  16. AUDIO_FILE_ENCODING_ALAW_8 = 27
  17. AUDIO_UNKNOWN_SIZE = 0xFFFFFFFFL
  18. _simple_encodings = [
  19.     AUDIO_FILE_ENCODING_MULAW_8,
  20.     AUDIO_FILE_ENCODING_LINEAR_8,
  21.     AUDIO_FILE_ENCODING_LINEAR_16,
  22.     AUDIO_FILE_ENCODING_LINEAR_24,
  23.     AUDIO_FILE_ENCODING_LINEAR_32,
  24.     AUDIO_FILE_ENCODING_ALAW_8]
  25.  
  26. class Error(Exception):
  27.     pass
  28.  
  29.  
  30. def _read_u32(file):
  31.     x = 0x0L
  32.     for i in range(4):
  33.         byte = file.read(1)
  34.         if byte == '':
  35.             raise EOFError
  36.         byte == ''
  37.         x = x * 256 + ord(byte)
  38.     
  39.     return x
  40.  
  41.  
  42. def _write_u32(file, x):
  43.     data = []
  44.     for i in range(4):
  45.         (d, m) = divmod(x, 256)
  46.         data.insert(0, m)
  47.         x = d
  48.     
  49.     for i in range(4):
  50.         file.write(chr(int(data[i])))
  51.     
  52.  
  53.  
  54. class Au_read:
  55.     
  56.     def __init__(self, f):
  57.         if type(f) == type(''):
  58.             import __builtin__
  59.             f = __builtin__.open(f, 'rb')
  60.         
  61.         self.initfp(f)
  62.  
  63.     
  64.     def __del__(self):
  65.         if self._file:
  66.             self.close()
  67.         
  68.  
  69.     
  70.     def initfp(self, file):
  71.         self._file = file
  72.         self._soundpos = 0
  73.         magic = int(_read_u32(file))
  74.         if magic != AUDIO_FILE_MAGIC:
  75.             raise Error, 'bad magic number'
  76.         magic != AUDIO_FILE_MAGIC
  77.         self._hdr_size = int(_read_u32(file))
  78.         if self._hdr_size < 24:
  79.             raise Error, 'header size too small'
  80.         self._hdr_size < 24
  81.         if self._hdr_size > 100:
  82.             raise Error, 'header size ridiculously large'
  83.         self._hdr_size > 100
  84.         self._data_size = _read_u32(file)
  85.         if self._data_size != AUDIO_UNKNOWN_SIZE:
  86.             self._data_size = int(self._data_size)
  87.         
  88.         self._encoding = int(_read_u32(file))
  89.         if self._encoding not in _simple_encodings:
  90.             raise Error, 'encoding not (yet) supported'
  91.         self._encoding not in _simple_encodings
  92.         if self._encoding in (AUDIO_FILE_ENCODING_MULAW_8, AUDIO_FILE_ENCODING_ALAW_8):
  93.             self._sampwidth = 2
  94.             self._framesize = 1
  95.         elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_8:
  96.             self._framesize = self._sampwidth = 1
  97.         elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_16:
  98.             self._framesize = self._sampwidth = 2
  99.         elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_24:
  100.             self._framesize = self._sampwidth = 3
  101.         elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_32:
  102.             self._framesize = self._sampwidth = 4
  103.         else:
  104.             raise Error, 'unknown encoding'
  105.         self._framerate = self._encoding in (AUDIO_FILE_ENCODING_MULAW_8, AUDIO_FILE_ENCODING_ALAW_8)(_read_u32(file))
  106.         self._nchannels = int(_read_u32(file))
  107.         self._framesize = self._framesize * self._nchannels
  108.         if self._hdr_size > 24:
  109.             self._info = file.read(self._hdr_size - 24)
  110.             for i in range(len(self._info)):
  111.                 if self._info[i] == '\x00':
  112.                     self._info = self._info[:i]
  113.                     break
  114.                     continue
  115.             
  116.         else:
  117.             self._info = ''
  118.  
  119.     
  120.     def getfp(self):
  121.         return self._file
  122.  
  123.     
  124.     def getnchannels(self):
  125.         return self._nchannels
  126.  
  127.     
  128.     def getsampwidth(self):
  129.         return self._sampwidth
  130.  
  131.     
  132.     def getframerate(self):
  133.         return self._framerate
  134.  
  135.     
  136.     def getnframes(self):
  137.         if self._data_size == AUDIO_UNKNOWN_SIZE:
  138.             return AUDIO_UNKNOWN_SIZE
  139.         if self._encoding in _simple_encodings:
  140.             return self._data_size / self._framesize
  141.         return 0
  142.  
  143.     
  144.     def getcomptype(self):
  145.         if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
  146.             return 'ULAW'
  147.         if self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
  148.             return 'ALAW'
  149.         return 'NONE'
  150.  
  151.     
  152.     def getcompname(self):
  153.         if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
  154.             return 'CCITT G.711 u-law'
  155.         if self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
  156.             return 'CCITT G.711 A-law'
  157.         return 'not compressed'
  158.  
  159.     
  160.     def getparams(self):
  161.         return (self.getnchannels(), self.getsampwidth(), self.getframerate(), self.getnframes(), self.getcomptype(), self.getcompname())
  162.  
  163.     
  164.     def getmarkers(self):
  165.         pass
  166.  
  167.     
  168.     def getmark(self, id):
  169.         raise Error, 'no marks'
  170.  
  171.     
  172.     def readframes(self, nframes):
  173.         if self._encoding in _simple_encodings:
  174.             if nframes == AUDIO_UNKNOWN_SIZE:
  175.                 data = self._file.read()
  176.             else:
  177.                 data = self._file.read(nframes * self._framesize * self._nchannels)
  178.             if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
  179.                 import audioop
  180.                 data = audioop.ulaw2lin(data, self._sampwidth)
  181.             
  182.             return data
  183.  
  184.     
  185.     def rewind(self):
  186.         self._soundpos = 0
  187.         self._file.seek(self._hdr_size)
  188.  
  189.     
  190.     def tell(self):
  191.         return self._soundpos
  192.  
  193.     
  194.     def setpos(self, pos):
  195.         if pos < 0 or pos > self.getnframes():
  196.             raise Error, 'position not in range'
  197.         pos > self.getnframes()
  198.         self._file.seek(pos * self._framesize + self._hdr_size)
  199.         self._soundpos = pos
  200.  
  201.     
  202.     def close(self):
  203.         self._file = None
  204.  
  205.  
  206.  
  207. class Au_write:
  208.     
  209.     def __init__(self, f):
  210.         if type(f) == type(''):
  211.             import __builtin__
  212.             f = __builtin__.open(f, 'wb')
  213.         
  214.         self.initfp(f)
  215.  
  216.     
  217.     def __del__(self):
  218.         if self._file:
  219.             self.close()
  220.         
  221.  
  222.     
  223.     def initfp(self, file):
  224.         self._file = file
  225.         self._framerate = 0
  226.         self._nchannels = 0
  227.         self._sampwidth = 0
  228.         self._framesize = 0
  229.         self._nframes = AUDIO_UNKNOWN_SIZE
  230.         self._nframeswritten = 0
  231.         self._datawritten = 0
  232.         self._datalength = 0
  233.         self._info = ''
  234.         self._comptype = 'ULAW'
  235.  
  236.     
  237.     def setnchannels(self, nchannels):
  238.         if self._nframeswritten:
  239.             raise Error, 'cannot change parameters after starting to write'
  240.         self._nframeswritten
  241.         if nchannels not in (1, 2, 4):
  242.             raise Error, 'only 1, 2, or 4 channels supported'
  243.         nchannels not in (1, 2, 4)
  244.         self._nchannels = nchannels
  245.  
  246.     
  247.     def getnchannels(self):
  248.         if not self._nchannels:
  249.             raise Error, 'number of channels not set'
  250.         self._nchannels
  251.         return self._nchannels
  252.  
  253.     
  254.     def setsampwidth(self, sampwidth):
  255.         if self._nframeswritten:
  256.             raise Error, 'cannot change parameters after starting to write'
  257.         self._nframeswritten
  258.         if sampwidth not in (1, 2, 4):
  259.             raise Error, 'bad sample width'
  260.         sampwidth not in (1, 2, 4)
  261.         self._sampwidth = sampwidth
  262.  
  263.     
  264.     def getsampwidth(self):
  265.         if not self._framerate:
  266.             raise Error, 'sample width not specified'
  267.         self._framerate
  268.         return self._sampwidth
  269.  
  270.     
  271.     def setframerate(self, framerate):
  272.         if self._nframeswritten:
  273.             raise Error, 'cannot change parameters after starting to write'
  274.         self._nframeswritten
  275.         self._framerate = framerate
  276.  
  277.     
  278.     def getframerate(self):
  279.         if not self._framerate:
  280.             raise Error, 'frame rate not set'
  281.         self._framerate
  282.         return self._framerate
  283.  
  284.     
  285.     def setnframes(self, nframes):
  286.         if self._nframeswritten:
  287.             raise Error, 'cannot change parameters after starting to write'
  288.         self._nframeswritten
  289.         if nframes < 0:
  290.             raise Error, '# of frames cannot be negative'
  291.         nframes < 0
  292.         self._nframes = nframes
  293.  
  294.     
  295.     def getnframes(self):
  296.         return self._nframeswritten
  297.  
  298.     
  299.     def setcomptype(self, type, name):
  300.         if type in ('NONE', 'ULAW'):
  301.             self._comptype = type
  302.         else:
  303.             raise Error, 'unknown compression type'
  304.         return type in ('NONE', 'ULAW')
  305.  
  306.     
  307.     def getcomptype(self):
  308.         return self._comptype
  309.  
  310.     
  311.     def getcompname(self):
  312.         if self._comptype == 'ULAW':
  313.             return 'CCITT G.711 u-law'
  314.         if self._comptype == 'ALAW':
  315.             return 'CCITT G.711 A-law'
  316.         return 'not compressed'
  317.  
  318.     
  319.     def setparams(self, .1):
  320.         (nchannels, sampwidth, framerate, nframes, comptype, compname) = .1
  321.         self.setnchannels(nchannels)
  322.         self.setsampwidth(sampwidth)
  323.         self.setframerate(framerate)
  324.         self.setnframes(nframes)
  325.         self.setcomptype(comptype, compname)
  326.  
  327.     
  328.     def getparams(self):
  329.         return (self.getnchannels(), self.getsampwidth(), self.getframerate(), self.getnframes(), self.getcomptype(), self.getcompname())
  330.  
  331.     
  332.     def tell(self):
  333.         return self._nframeswritten
  334.  
  335.     
  336.     def writeframesraw(self, data):
  337.         self._ensure_header_written()
  338.         nframes = len(data) / self._framesize
  339.         if self._comptype == 'ULAW':
  340.             import audioop
  341.             data = audioop.lin2ulaw(data, self._sampwidth)
  342.         
  343.         self._file.write(data)
  344.         self._nframeswritten = self._nframeswritten + nframes
  345.         self._datawritten = self._datawritten + len(data)
  346.  
  347.     
  348.     def writeframes(self, data):
  349.         self.writeframesraw(data)
  350.         if self._nframeswritten != self._nframes or self._datalength != self._datawritten:
  351.             self._patchheader()
  352.         
  353.  
  354.     
  355.     def close(self):
  356.         self._ensure_header_written()
  357.         if self._nframeswritten != self._nframes or self._datalength != self._datawritten:
  358.             self._patchheader()
  359.         
  360.         self._file.flush()
  361.         self._file = None
  362.  
  363.     
  364.     def _ensure_header_written(self):
  365.         if not self._nframeswritten:
  366.             if not self._nchannels:
  367.                 raise Error, '# of channels not specified'
  368.             self._nchannels
  369.             if not self._sampwidth:
  370.                 raise Error, 'sample width not specified'
  371.             self._sampwidth
  372.             if not self._framerate:
  373.                 raise Error, 'frame rate not specified'
  374.             self._framerate
  375.             self._write_header()
  376.         
  377.  
  378.     
  379.     def _write_header(self):
  380.         if self._comptype == 'NONE':
  381.             if self._sampwidth == 1:
  382.                 encoding = AUDIO_FILE_ENCODING_LINEAR_8
  383.                 self._framesize = 1
  384.             elif self._sampwidth == 2:
  385.                 encoding = AUDIO_FILE_ENCODING_LINEAR_16
  386.                 self._framesize = 2
  387.             elif self._sampwidth == 4:
  388.                 encoding = AUDIO_FILE_ENCODING_LINEAR_32
  389.                 self._framesize = 4
  390.             else:
  391.                 raise Error, 'internal error'
  392.         self._sampwidth == 1
  393.         if self._comptype == 'ULAW':
  394.             encoding = AUDIO_FILE_ENCODING_MULAW_8
  395.             self._framesize = 1
  396.         else:
  397.             raise Error, 'internal error'
  398.         self._framesize = (self._comptype == 'ULAW')._framesize * self._nchannels
  399.         _write_u32(self._file, AUDIO_FILE_MAGIC)
  400.         header_size = 25 + len(self._info)
  401.         header_size = header_size + 7 & -8
  402.         _write_u32(self._file, header_size)
  403.         if self._nframes == AUDIO_UNKNOWN_SIZE:
  404.             length = AUDIO_UNKNOWN_SIZE
  405.         else:
  406.             length = self._nframes * self._framesize
  407.         _write_u32(self._file, length)
  408.         self._datalength = length
  409.         _write_u32(self._file, encoding)
  410.         _write_u32(self._file, self._framerate)
  411.         _write_u32(self._file, self._nchannels)
  412.         self._file.write(self._info)
  413.         self._file.write('\x00' * (header_size - len(self._info) - 24))
  414.  
  415.     
  416.     def _patchheader(self):
  417.         self._file.seek(8)
  418.         _write_u32(self._file, self._datawritten)
  419.         self._datalength = self._datawritten
  420.         self._file.seek(0, 2)
  421.  
  422.  
  423.  
  424. def open(f, mode = None):
  425.     if mode is None:
  426.         if hasattr(f, 'mode'):
  427.             mode = f.mode
  428.         else:
  429.             mode = 'rb'
  430.     
  431.     if mode in ('r', 'rb'):
  432.         return Au_read(f)
  433.     if mode in ('w', 'wb'):
  434.         return Au_write(f)
  435.     raise Error, "mode must be 'r', 'rb', 'w', or 'wb'"
  436.  
  437. openfp = open
  438.