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