"""Stuff to parse AIFF-C and AIFF files. Unless explicitly stated otherwise, the description below is trueboth for AIFF-C files and AIFF files. An AIFF-C file has the following structure.   +-----------------+  | FORM            |  +-----------------+  | <size>          |  +----+------------+  |    | AIFC       |  |    +------------+  |    | <chunks>   |  |    |    .       |  |    |    .       |  |    |    .       |  +----+------------+ An AIFF file has the string "AIFF" instead of "AIFC". A chunk consists of an identifier (4 bytes) followed by a size (4 bytes,big endian order), followed by the data.  The size field does not includethe size of the 8 byte header. The following chunk types are recognized.   FVER      <version number of AIFF-C defining document> (AIFF-C only).  MARK      <# of markers> (2 bytes)      list of markers:          <marker ID> (2 bytes, must be > 0)          <position> (4 bytes)          <marker name> ("pstring")  COMM      <# of channels> (2 bytes)      <# of sound frames> (4 bytes)      <size of the samples> (2 bytes)      <sampling frequency> (10 bytes, IEEE 80-bit extended          floating point)      in AIFF-C files only:      <compression type> (4 bytes)      <human-readable version of compression type> ("pstring")  SSND      <offset> (4 bytes, not used by this program)      <blocksize> (4 bytes, not used by this program)      <sound data> A pstring consists of 1 byte length, a string of characters, and 0 or 1byte pad to make the total length even. Usage. Reading AIFF files:  f = aifc.open(file, 'r')where file is either the name of a file or an open file pointer.The open file pointer must have methods read(), seek(), and close().In some types of audio files, if the setpos() method is not used,the seek() method is not necessary. This returns an instance of a class with the following public methods:  getnchannels()  -- returns number of audio channels (1 for             mono, 2 for stereo)  getsampwidth()  -- returns sample width in bytes  getframerate()  -- returns sampling frequency  getnframes()    -- returns number of audio frames  getcomptype()   -- returns compression type ('NONE' for AIFF files)  getcompname()   -- returns human-readable version of             compression type ('not compressed' for AIFF files)  getparams() -- returns a tuple consisting of all of the             above in the above order  getmarkers()    -- get the list of marks in the audio file or None             if there are no marks  getmark(id) -- get mark with the specified id (raises an error             if the mark does not exist)  readframes(n)   -- returns at most n frames of audio  rewind()    -- rewind to the beginning of the audio stream  setpos(pos) -- seek to the specified position  tell()      -- return the current position  close()     -- close the instance (make it unusable)The position returned by tell(), the position given to setpos() andthe position of marks are all compatible and have nothing to do withthe actual position in the file.The close() method is called automatically when the class instanceis destroyed. Writing AIFF files:  f = aifc.open(file, 'w')where file is either the name of a file or an open file pointer.The open file pointer must have methods write(), tell(), seek(), andclose(). This returns an instance of a class with the following public methods:  aiff()      -- create an AIFF file (AIFF-C default)  aifc()      -- create an AIFF-C file  setnchannels(n) -- set the number of channels  setsampwidth(n) -- set the sample width  setframerate(n) -- set the frame rate  setnframes(n)   -- set the number of frames  setcomptype(type, name)          -- set the compression type and the             human-readable compression type  setparams(tuple)          -- set all parameters at once  setmark(id, pos, name)          -- add specified mark to the list of marks  tell()      -- return current position in output file (useful             in combination with setmark())  writeframesraw(data)          -- write audio frames without pathing up the             file header  writeframes(data)          -- write audio frames and patch up the file header  close()     -- patch up the file header and close the             output fileYou should set the parameters before the first writeframesraw orwriteframes.  The total number of frames does not need to be set,but when it is set to the correct value, the header does not have tobe patched up.It is best to first set all parameters, perhaps possibly thecompression type, and then write audio frames using writeframesraw.When all frames have been written, either call writeframes('') orclose() to patch up the sizes in the header.Marks can be added anytime.  If there are any marks, ypu must callclose() after all frames have been written.The close() method is called automatically when the class instanceis destroyed. When a file is opened with the extension '.aiff', an AIFF file iswritten, otherwise an AIFF-C file is written.  This default can bechanged by calling aiff() or aifc() before the first writeframes orwriteframesraw.""" import structimport __builtin__ __all__ = ["Error","open","openfp"] class Error(Exception):    pass _AIFC_version = 0xA2805140L     # Version 1 of AIFF-C _skiplist = 'COMT', 'INST', 'MIDI', 'AESD', \      'APPL', 'NAME', 'AUTH', '(c) ', 'ANNO' def _read_long(file):    try:        return struct.unpack('>l', file.read(4))[0]    except struct.error:        raise EOFError def _read_ulong(file):    try:        return struct.unpack('>L', file.read(4))[0]    except struct.error:        raise EOFError def _read_short(file):    try:        return struct.unpack('>h', file.read(2))[0]    except struct.error:        raise EOFError def _read_string(file):    length = ord(file.read(1))    if length == 0:        data = ''    else:        data = file.read(length)    if length & 1 == 0:        dummy = file.read(1)    return data _HUGE_VAL = 1.79769313486231e+308 # See <limits.h> def _read_float(f): # 10 bytes    expon = _read_short(f) # 2 bytes    sign = 1    if expon < 0:        sign = -1        expon = expon + 0x8000    himant = _read_ulong(f) # 4 bytes    lomant = _read_ulong(f) # 4 bytes    if expon == himant == lomant == 0:        f = 0.0    elif expon == 0x7FFF:        f = _HUGE_VAL    else:        expon = expon - 16383        f = (himant * 0x100000000L + lomant) * pow(2.0, expon - 63)    return sign * f def _write_short(f, x):    f.write(struct.pack('>h', x)) def _write_long(f, x):    f.write(struct.pack('>L', x)) def _write_string(f, s):    if len(s) > 255:        raise ValueError("string exceeds maximum pstring length")    f.write(chr(len(s)))    f.write(s)    if len(s) & 1 == 0:        f.write(chr(0)) def _write_float(f, x):    import math    if x < 0:        sign = 0x8000        x = x * -1    else:        sign = 0    if x == 0:        expon = 0        himant = 0        lomant = 0    else:        fmant, expon = math.frexp(x)        if expon > 16384 or fmant >= 1:     # Infinity or NaN            expon = sign|0x7FFF            himant = 0            lomant = 0        else:                   # Finite            expon = expon + 16382            if expon < 0:           # denormalized                fmant = math.ldexp(fmant, expon)                expon = 0            expon = expon | sign            fmant = math.ldexp(fmant, 32)            fsmant = math.floor(fmant)            himant = long(fsmant)            fmant = math.ldexp(fmant - fsmant, 32)            fsmant = math.floor(fmant)            lomant = long(fsmant)    _write_short(f, expon)    _write_long(f, himant)    _write_long(f, lomant) from chunk import Chunk class Aifc_read:    # Variables used in this class:    #    # These variables are available to the user though appropriate    # methods of this class:    # _file -- the open file with methods read(), close(), and seek()    #       set through the __init__() method    # _nchannels -- the number of audio channels    #       available through the getnchannels() method    # _nframes -- the number of audio frames    #       available through the getnframes() method    # _sampwidth -- the number of bytes per audio sample    #       available through the getsampwidth() method    # _framerate -- the sampling frequency    #       available through the getframerate() method    # _comptype -- the AIFF-C compression type ('NONE' if AIFF)    #       available through the getcomptype() method    # _compname -- the human-readable AIFF-C compression type    #       available through the getcomptype() method    # _markers -- the marks in the audio file    #       available through the getmarkers() and getmark()    #       methods    # _soundpos -- the position in the audio stream    #       available through the tell() method, set through the    #       setpos() method    #    # These variables are used internally only:    # _version -- the AIFF-C version number    # _decomp -- the decompressor from builtin module cl    # _comm_chunk_read -- 1 iff the COMM chunk has been read    # _aifc -- 1 iff reading an AIFF-C file    # _ssnd_seek_needed -- 1 iff positioned correctly in audio    #       file for readframes()    # _ssnd_chunk -- instantiation of a chunk class for the SSND chunk    # _framesize -- size of one frame in the file     def initfp(self, file):        self._version = 0        self._decomp = None        self._convert = None        self._markers = []        self._soundpos = 0        self._file = Chunk(file)        if self._file.getname() != 'FORM':            raise Error, 'file does not start with FORM id'        formdata = self._file.read(4)        if formdata == 'AIFF':            self._aifc = 0        elif formdata == 'AIFC':            self._aifc = 1        else:            raise Error, 'not an AIFF or AIFF-C file'        self._comm_chunk_read = 0        while 1:            self._ssnd_seek_needed = 1            try:                chunk = Chunk(self._file)            except EOFError:                break            chunkname = chunk.getname()            if chunkname == 'COMM':                self._read_comm_chunk(chunk)                self._comm_chunk_read = 1            elif chunkname == 'SSND':                self._ssnd_chunk = chunk                dummy = chunk.read(8)                self._ssnd_seek_needed = 0            elif chunkname == 'FVER':                self._version = _read_ulong(chunk)            elif chunkname == 'MARK':                self._readmark(chunk)            elif chunkname in _skiplist:                pass            else:                raise Error, 'unrecognized chunk type '+chunk.chunkname            chunk.skip()        if not self._comm_chunk_read or not self._ssnd_chunk:            raise Error, 'COMM chunk and/or SSND chunk missing'        if self._aifc and self._decomp:            import cl            params = [cl.ORIGINAL_FORMAT, 0,                  cl.BITS_PER_COMPONENT, self._sampwidth * 8,                  cl.FRAME_RATE, self._framerate]            if self._nchannels == 1:                params[1] = cl.MONO            elif self._nchannels == 2:                params[1] = cl.STEREO_INTERLEAVED            else:                raise Error, 'cannot compress more than 2 channels'            self._decomp.SetParams(params)     def __init__(self, f):        if type(f) == type(''):            f = __builtin__.open(f, 'rb')        # else, assume it is an open file object already        self.initfp(f)     #    # User visible methods.    #    def getfp(self):        return self._file     def rewind(self):        self._ssnd_seek_needed = 1        self._soundpos = 0     def close(self):        if self._decomp:            self._decomp.CloseDecompressor()            self._decomp = None        self._file = None     def tell(self):        return self._soundpos     def getnchannels(self):        return self._nchannels     def getnframes(self):        return self._nframes     def getsampwidth(self):        return self._sampwidth     def getframerate(self):        return self._framerate     def getcomptype(self):        return self._comptype     def getcompname(self):        return self._compname ##  def getversion(self):##      return self._version     def getparams(self):        return self.getnchannels(), self.getsampwidth(), \              self.getframerate(), self.getnframes(), \              self.getcomptype(), self.getcompname()     def getmarkers(self):        if len(self._markers) == 0:            return None        return self._markers     def getmark(self, id):        for marker in self._markers:            if id == marker[0]:                return marker        raise Error, 'marker %r does not exist' % (id,)     def setpos(self, pos):        if pos < 0 or pos > self._nframes:            raise Error, 'position not in range'        self._soundpos = pos        self._ssnd_seek_needed = 1     def readframes(self, nframes):        if self._ssnd_seek_needed:            self._ssnd_chunk.seek(0)            dummy = self._ssnd_chunk.read(8)            pos = self._soundpos * self._framesize            if pos:                self._ssnd_chunk.seek(pos + 8)            self._ssnd_seek_needed = 0        if nframes == 0:            return ''        data = self._ssnd_chunk.read(nframes * self._framesize)        if self._convert and data:            data = self._convert(data)        self._soundpos = self._soundpos + len(data) / (self._nchannels * self._sampwidth)        return data     #    # Internal methods.    #     def _decomp_data(self, data):        import cl        dummy = self._decomp.SetParam(cl.FRAME_BUFFER_SIZE,                          len(data) * 2)        return self._decomp.Decompress(len(data) / self._nchannels,                           data)     def _ulaw2lin(self, data):        import audioop        return audioop.ulaw2lin(data, 2)     def _adpcm2lin(self, data):        import audioop        if not hasattr(self, '_adpcmstate'):            # first time            self._adpcmstate = None        data, self._adpcmstate = audioop.adpcm2lin(data, 2,                               self._adpcmstate)        return data     def _read_comm_chunk(self, chunk):        self._nchannels = _read_short(chunk)        self._nframes = _read_long(chunk)        self._sampwidth = (_read_short(chunk) + 7) / 8        self._framerate = int(_read_float(chunk))        self._framesize = self._nchannels * self._sampwidth        if self._aifc:            #DEBUG: SGI's soundeditor produces a bad size :-(            kludge = 0            if chunk.chunksize == 18:                kludge = 1                print 'Warning: bad COMM chunk size'                chunk.chunksize = 23            #DEBUG end            self._comptype = chunk.read(4)            #DEBUG start            if kludge:                length = ord(chunk.file.read(1))                if length & 1 == 0:                    length = length + 1                chunk.chunksize = chunk.chunksize + length                chunk.file.seek(-1, 1)            #DEBUG end            self._compname = _read_string(chunk)            if self._comptype != 'NONE':                if self._comptype == 'G722':                    try:                        import audioop                    except ImportError:                        pass                    else:                        self._convert = self._adpcm2lin                        self._framesize = self._framesize / 4                        return                # for ULAW and ALAW try Compression Library                try:                    import cl                except ImportError:                    if self._comptype == 'ULAW':                        try:                            import audioop                            self._convert = self._ulaw2lin                            self._framesize = self._framesize / 2                            return                        except ImportError:                            pass                    raise Error, 'cannot read compressed AIFF-C files'                if self._comptype == 'ULAW':                    scheme = cl.G711_ULAW                    self._framesize = self._framesize / 2                elif self._comptype == 'ALAW':                    scheme = cl.G711_ALAW                    self._framesize = self._framesize / 2                else:                    raise Error, 'unsupported compression type'                self._decomp = cl.OpenDecompressor(scheme)

Lines 1–500 of 961. Load more