1 """Stuff to parse AIFF-C and AIFF files.

     2 

     3 Unless explicitly stated otherwise, the description below is true

     4 both for AIFF-C files and AIFF files.

     5 

     6 An AIFF-C file has the following structure.

     7 

     8   +-----------------+

     9   | FORM            |

    10   +-----------------+

    11   | <size>          |

    12   +----+------------+

    13   |    | AIFC       |

    14   |    +------------+

    15   |    | <chunks>   |

    16   |    |    .       |

    17   |    |    .       |

    18   |    |    .       |

    19   +----+------------+

    20 

    21 An AIFF file has the string "AIFF" instead of "AIFC".

    22 

    23 A chunk consists of an identifier (4 bytes) followed by a size (4 bytes,

    24 big endian order), followed by the data.  The size field does not include

    25 the size of the 8 byte header.

    26 

    27 The following chunk types are recognized.

    28 

    29   FVER

    30       <version number of AIFF-C defining document> (AIFF-C only).

    31   MARK

    32       <# of markers> (2 bytes)

    33       list of markers:

    34           <marker ID> (2 bytes, must be > 0)

    35           <position> (4 bytes)

    36           <marker name> ("pstring")

    37   COMM

    38       <# of channels> (2 bytes)

    39       <# of sound frames> (4 bytes)

    40       <size of the samples> (2 bytes)

    41       <sampling frequency> (10 bytes, IEEE 80-bit extended

    42           floating point)

    43       in AIFF-C files only:

    44       <compression type> (4 bytes)

    45       <human-readable version of compression type> ("pstring")

    46   SSND

    47       <offset> (4 bytes, not used by this program)

    48       <blocksize> (4 bytes, not used by this program)

    49       <sound data>

    50 

    51 A pstring consists of 1 byte length, a string of characters, and 0 or 1

    52 byte pad to make the total length even.

    53 

    54 Usage.

    55 

    56 Reading AIFF files:

    57   f = aifc.open(file, 'r')

    58 where file is either the name of a file or an open file pointer.

    59 The open file pointer must have methods read(), seek(), and close().

    60 In some types of audio files, if the setpos() method is not used,

    61 the seek() method is not necessary.

    62 

    63 This returns an instance of a class with the following public methods:

    64   getnchannels()  -- returns number of audio channels (1 for

    65              mono, 2 for stereo)

    66   getsampwidth()  -- returns sample width in bytes

    67   getframerate()  -- returns sampling frequency

    68   getnframes()    -- returns number of audio frames

    69   getcomptype()   -- returns compression type ('NONE' for AIFF files)

    70   getcompname()   -- returns human-readable version of

    71              compression type ('not compressed' for AIFF files)

    72   getparams() -- returns a tuple consisting of all of the

    73              above in the above order

    74   getmarkers()    -- get the list of marks in the audio file or None

    75              if there are no marks

    76   getmark(id) -- get mark with the specified id (raises an error

    77              if the mark does not exist)

    78   readframes(n)   -- returns at most n frames of audio

    79   rewind()    -- rewind to the beginning of the audio stream

    80   setpos(pos) -- seek to the specified position

    81   tell()      -- return the current position

    82   close()     -- close the instance (make it unusable)

    83 The position returned by tell(), the position given to setpos() and

    84 the position of marks are all compatible and have nothing to do with

    85 the actual position in the file.

    86 The close() method is called automatically when the class instance

    87 is destroyed.

    88 

    89 Writing AIFF files:

    90   f = aifc.open(file, 'w')

    91 where file is either the name of a file or an open file pointer.

    92 The open file pointer must have methods write(), tell(), seek(), and

    93 close().

    94 

    95 This returns an instance of a class with the following public methods:

    96   aiff()      -- create an AIFF file (AIFF-C default)

    97   aifc()      -- create an AIFF-C file

    98   setnchannels(n) -- set the number of channels

    99   setsampwidth(n) -- set the sample width

   100   setframerate(n) -- set the frame rate

   101   setnframes(n)   -- set the number of frames

   102   setcomptype(type, name)

   103           -- set the compression type and the

   104              human-readable compression type

   105   setparams(tuple)

   106           -- set all parameters at once

   107   setmark(id, pos, name)

   108           -- add specified mark to the list of marks

   109   tell()      -- return current position in output file (useful

   110              in combination with setmark())

   111   writeframesraw(data)

   112           -- write audio frames without pathing up the

   113              file header

   114   writeframes(data)

   115           -- write audio frames and patch up the file header

   116   close()     -- patch up the file header and close the

   117              output file

   118 You should set the parameters before the first writeframesraw or

   119 writeframes.  The total number of frames does not need to be set,

   120 but when it is set to the correct value, the header does not have to

   121 be patched up.

   122 It is best to first set all parameters, perhaps possibly the

   123 compression type, and then write audio frames using writeframesraw.

   124 When all frames have been written, either call writeframes('') or

   125 close() to patch up the sizes in the header.

   126 Marks can be added anytime.  If there are any marks, ypu must call

   127 close() after all frames have been written.

   128 The close() method is called automatically when the class instance

   129 is destroyed.

   130 

   131 When a file is opened with the extension '.aiff', an AIFF file is

   132 written, otherwise an AIFF-C file is written.  This default can be

   133 changed by calling aiff() or aifc() before the first writeframes or

   134 writeframesraw.

   135 """

   136 

   137 import struct

   138 import __builtin__

   139 

   140 __all__ = ["Error","open","openfp"]

   141 

   142 class Error(Exception):

   143     pass

   144 

   145 _AIFC_version = 0xA2805140L     # Version 1 of AIFF-C

   146 

   147 _skiplist = 'COMT', 'INST', 'MIDI', 'AESD', \

   148       'APPL', 'NAME', 'AUTH', '(c) ', 'ANNO'

   149 

   150 def _read_long(file):

   151     try:

   152         return struct.unpack('>l', file.read(4))[0]

   153     except struct.error:

   154         raise EOFError

   155 

   156 def _read_ulong(file):

   157     try:

   158         return struct.unpack('>L', file.read(4))[0]

   159     except struct.error:

   160         raise EOFError

   161 

   162 def _read_short(file):

   163     try:

   164         return struct.unpack('>h', file.read(2))[0]

   165     except struct.error:

   166         raise EOFError

   167 

   168 def _read_string(file):

   169     length = ord(file.read(1))

   170     if length == 0:

   171         data = ''

   172     else:

   173         data = file.read(length)

   174     if length & 1 == 0:

   175         dummy = file.read(1)

   176     return data

   177 

   178 _HUGE_VAL = 1.79769313486231e+308 # See <limits.h>

   179 

   180 def _read_float(f): # 10 bytes

   181     expon = _read_short(f) # 2 bytes

   182     sign = 1

   183     if expon < 0:

   184         sign = -1

   185         expon = expon + 0x8000

   186     himant = _read_ulong(f) # 4 bytes

   187     lomant = _read_ulong(f) # 4 bytes

   188     if expon == himant == lomant == 0:

   189         f = 0.0

   190     elif expon == 0x7FFF:

   191         f = _HUGE_VAL

   192     else:

   193         expon = expon - 16383

   194         f = (himant * 0x100000000L + lomant) * pow(2.0, expon - 63)

   195     return sign * f

   196 

   197 def _write_short(f, x):

   198     f.write(struct.pack('>h', x))

   199 

   200 def _write_long(f, x):

   201     f.write(struct.pack('>L', x))

   202 

   203 def _write_string(f, s):

   204     if len(s) > 255:

   205         raise ValueError("string exceeds maximum pstring length")

   206     f.write(chr(len(s)))

   207     f.write(s)

   208     if len(s) & 1 == 0:

   209         f.write(chr(0))

   210 

   211 def _write_float(f, x):

   212     import math

   213     if x < 0:

   214         sign = 0x8000

   215         x = x * -1

   216     else:

   217         sign = 0

   218     if x == 0:

   219         expon = 0

   220         himant = 0

   221         lomant = 0

   222     else:

   223         fmant, expon = math.frexp(x)

   224         if expon > 16384 or fmant >= 1:     # Infinity or NaN

   225             expon = sign|0x7FFF

   226             himant = 0

   227             lomant = 0

   228         else:                   # Finite

   229             expon = expon + 16382

   230             if expon < 0:           # denormalized

   231                 fmant = math.ldexp(fmant, expon)

   232                 expon = 0

   233             expon = expon | sign

   234             fmant = math.ldexp(fmant, 32)

   235             fsmant = math.floor(fmant)

   236             himant = long(fsmant)

   237             fmant = math.ldexp(fmant - fsmant, 32)

   238             fsmant = math.floor(fmant)

   239             lomant = long(fsmant)

   240     _write_short(f, expon)

   241     _write_long(f, himant)

   242     _write_long(f, lomant)

   243 

   244 from chunk import Chunk

   245 

   246 class Aifc_read:

   247     # Variables used in this class:

   248     #

   249     # These variables are available to the user though appropriate

   250     # methods of this class:

   251     # _file -- the open file with methods read(), close(), and seek()

   252     #       set through the __init__() method

   253     # _nchannels -- the number of audio channels

   254     #       available through the getnchannels() method

   255     # _nframes -- the number of audio frames

   256     #       available through the getnframes() method

   257     # _sampwidth -- the number of bytes per audio sample

   258     #       available through the getsampwidth() method

   259     # _framerate -- the sampling frequency

   260     #       available through the getframerate() method

   261     # _comptype -- the AIFF-C compression type ('NONE' if AIFF)

   262     #       available through the getcomptype() method

   263     # _compname -- the human-readable AIFF-C compression type

   264     #       available through the getcomptype() method

   265     # _markers -- the marks in the audio file

   266     #       available through the getmarkers() and getmark()

   267     #       methods

   268     # _soundpos -- the position in the audio stream

   269     #       available through the tell() method, set through the

   270     #       setpos() method

   271     #

   272     # These variables are used internally only:

   273     # _version -- the AIFF-C version number

   274     # _decomp -- the decompressor from builtin module cl

   275     # _comm_chunk_read -- 1 iff the COMM chunk has been read

   276     # _aifc -- 1 iff reading an AIFF-C file

   277     # _ssnd_seek_needed -- 1 iff positioned correctly in audio

   278     #       file for readframes()

   279     # _ssnd_chunk -- instantiation of a chunk class for the SSND chunk

   280     # _framesize -- size of one frame in the file

   281 

   282     def initfp(self, file):

   283         self._version = 0

   284         self._decomp = None

   285         self._convert = None

   286         self._markers = []

   287         self._soundpos = 0

   288         self._file = Chunk(file)

   289         if self._file.getname() != 'FORM':

   290             raise Error, 'file does not start with FORM id'

   291         formdata = self._file.read(4)

   292         if formdata == 'AIFF':

   293             self._aifc = 0

   294         elif formdata == 'AIFC':

   295             self._aifc = 1

   296         else:

   297             raise Error, 'not an AIFF or AIFF-C file'

   298         self._comm_chunk_read = 0

   299         while 1:

   300             self._ssnd_seek_needed = 1

   301             try:

   302                 chunk = Chunk(self._file)

   303             except EOFError:

   304                 break

   305             chunkname = chunk.getname()

   306             if chunkname == 'COMM':

   307                 self._read_comm_chunk(chunk)

   308                 self._comm_chunk_read = 1

   309             elif chunkname == 'SSND':

   310                 self._ssnd_chunk = chunk

   311                 dummy = chunk.read(8)

   312                 self._ssnd_seek_needed = 0

   313             elif chunkname == 'FVER':

   314                 self._version = _read_ulong(chunk)

   315             elif chunkname == 'MARK':

   316                 self._readmark(chunk)

   317             elif chunkname in _skiplist:

   318                 pass

   319             else:

   320                 raise Error, 'unrecognized chunk type '+chunk.chunkname

   321             chunk.skip()

   322         if not self._comm_chunk_read or not self._ssnd_chunk:

   323             raise Error, 'COMM chunk and/or SSND chunk missing'

   324         if self._aifc and self._decomp:

   325             import cl

   326             params = [cl.ORIGINAL_FORMAT, 0,

   327                   cl.BITS_PER_COMPONENT, self._sampwidth * 8,

   328                   cl.FRAME_RATE, self._framerate]

   329             if self._nchannels == 1:

   330                 params[1] = cl.MONO

   331             elif self._nchannels == 2:

   332                 params[1] = cl.STEREO_INTERLEAVED

   333             else:

   334                 raise Error, 'cannot compress more than 2 channels'

   335             self._decomp.SetParams(params)

   336 

   337     def __init__(self, f):

   338         if type(f) == type(''):

   339             f = __builtin__.open(f, 'rb')

   340         # else, assume it is an open file object already

   341         self.initfp(f)

   342 

   343     #

   344     # User visible methods.

   345     #

   346     def getfp(self):

   347         return self._file

   348 

   349     def rewind(self):

   350         self._ssnd_seek_needed = 1

   351         self._soundpos = 0

   352 

   353     def close(self):

   354         if self._decomp:

   355             self._decomp.CloseDecompressor()

   356             self._decomp = None

   357         self._file = None

   358 

   359     def tell(self):

   360         return self._soundpos

   361 

   362     def getnchannels(self):

   363         return self._nchannels

   364 

   365     def getnframes(self):

   366         return self._nframes

   367 

   368     def getsampwidth(self):

   369         return self._sampwidth

   370 

   371     def getframerate(self):

   372         return self._framerate

   373 

   374     def getcomptype(self):

   375         return self._comptype

   376 

   377     def getcompname(self):

   378         return self._compname

   379 

   380 ##  def getversion(self):

   381 ##      return self._version

   382 

   383     def getparams(self):

   384         return self.getnchannels(), self.getsampwidth(), \

   385               self.getframerate(), self.getnframes(), \

   386               self.getcomptype(), self.getcompname()

   387 

   388     def getmarkers(self):

   389         if len(self._markers) == 0:

   390             return None

   391         return self._markers

   392 

   393     def getmark(self, id):

   394         for marker in self._markers:

   395             if id == marker[0]:

   396                 return marker

   397         raise Error, 'marker %r does not exist' % (id,)

   398 

   399     def setpos(self, pos):

   400         if pos < 0 or pos > self._nframes:

   401             raise Error, 'position not in range'

   402         self._soundpos = pos

   403         self._ssnd_seek_needed = 1

   404 

   405     def readframes(self, nframes):

   406         if self._ssnd_seek_needed:

   407             self._ssnd_chunk.seek(0)

   408             dummy = self._ssnd_chunk.read(8)

   409             pos = self._soundpos * self._framesize

   410             if pos:

   411                 self._ssnd_chunk.seek(pos + 8)

   412             self._ssnd_seek_needed = 0

   413         if nframes == 0:

   414             return ''

   415         data = self._ssnd_chunk.read(nframes * self._framesize)

   416         if self._convert and data:

   417             data = self._convert(data)

   418         self._soundpos = self._soundpos + len(data) / (self._nchannels * self._sampwidth)

   419         return data

   420 

   421     #

   422     # Internal methods.

   423     #

   424 

   425     def _decomp_data(self, data):

   426         import cl

   427         dummy = self._decomp.SetParam(cl.FRAME_BUFFER_SIZE,

   428                           len(data) * 2)

   429         return self._decomp.Decompress(len(data) / self._nchannels,

   430                            data)

   431 

   432     def _ulaw2lin(self, data):

   433         import audioop

   434         return audioop.ulaw2lin(data, 2)

   435 

   436     def _adpcm2lin(self, data):

   437         import audioop

   438         if not hasattr(self, '_adpcmstate'):

   439             # first time

   440             self._adpcmstate = None

   441         data, self._adpcmstate = audioop.adpcm2lin(data, 2,

   442                                self._adpcmstate)

   443         return data

   444 

   445     def _read_comm_chunk(self, chunk):

   446         self._nchannels = _read_short(chunk)

   447         self._nframes = _read_long(chunk)

   448         self._sampwidth = (_read_short(chunk) + 7) / 8

   449         self._framerate = int(_read_float(chunk))

   450         self._framesize = self._nchannels * self._sampwidth

   451         if self._aifc:

   452             #DEBUG: SGI's soundeditor produces a bad size :-(

   453             kludge = 0

   454             if chunk.chunksize == 18:

   455                 kludge = 1

   456                 print 'Warning: bad COMM chunk size'

   457                 chunk.chunksize = 23

   458             #DEBUG end

   459             self._comptype = chunk.read(4)

   460             #DEBUG start

   461             if kludge:

   462                 length = ord(chunk.file.read(1))

   463                 if length & 1 == 0:

   464                     length = length + 1

   465                 chunk.chunksize = chunk.chunksize + length

   466                 chunk.file.seek(-1, 1)

   467             #DEBUG end

   468             self._compname = _read_string(chunk)

   469             if self._comptype != 'NONE':

   470                 if self._comptype == 'G722':

   471                     try:

   472                         import audioop

   473                     except ImportError:

   474                         pass

   475                     else:

   476                         self._convert = self._adpcm2lin

   477                         self._framesize = self._framesize / 4

   478                         return

   479                 # for ULAW and ALAW try Compression Library

   480                 try:

   481                     import cl

   482                 except ImportError:

   483                     if self._comptype == 'ULAW':

   484                         try:

   485                             import audioop

   486                             self._convert = self._ulaw2lin

   487                             self._framesize = self._framesize / 2

   488                             return

   489                         except ImportError:

   490                             pass

   491                     raise Error, 'cannot read compressed AIFF-C files'

   492                 if self._comptype == 'ULAW':

   493                     scheme = cl.G711_ULAW

   494                     self._framesize = self._framesize / 2

   495                 elif self._comptype == 'ALAW':

   496                     scheme = cl.G711_ALAW

   497                     self._framesize = self._framesize / 2

   498                 else:

   499                     raise Error, 'unsupported compression type'

   500                 self._decomp = cl.OpenDecompressor(scheme)

   501                 self._convert = self._decomp_data

   502         else:

   503             self._comptype = 'NONE'

   504             self._compname = 'not compressed'

   505 

   506     def _readmark(self, chunk):

   507         nmarkers = _read_short(chunk)

   508         # Some files appear to contain invalid counts.

   509         # Cope with this by testing for EOF.

   510         try:

   511             for i in range(nmarkers):

   512                 id = _read_short(chunk)

   513                 pos = _read_long(chunk)

   514                 name = _read_string(chunk)

   515                 if pos or name:

   516                     # some files appear to have

   517                     # dummy markers consisting of

   518                     # a position 0 and name ''

   519                     self._markers.append((id, pos, name))

   520         except EOFError:

   521             print 'Warning: MARK chunk contains only',

   522             print len(self._markers),

   523             if len(self._markers) == 1: print 'marker',

   524             else: print 'markers',

   525             print 'instead of', nmarkers

   526 

   527 class Aifc_write:

   528     # Variables used in this class:

   529     #

   530     # These variables are user settable through appropriate methods

   531     # of this class:

   532     # _file -- the open file with methods write(), close(), tell(), seek()

   533     #       set through the __init__() method

   534     # _comptype -- the AIFF-C compression type ('NONE' in AIFF)

   535     #       set through the setcomptype() or setparams() method

   536     # _compname -- the human-readable AIFF-C compression type

   537     #       set through the setcomptype() or setparams() method

   538     # _nchannels -- the number of audio channels

   539     #       set through the setnchannels() or setparams() method

   540     # _sampwidth -- the number of bytes per audio sample

   541     #       set through the setsampwidth() or setparams() method

   542     # _framerate -- the sampling frequency

   543     #       set through the setframerate() or setparams() method

   544     # _nframes -- the number of audio frames written to the header

   545     #       set through the setnframes() or setparams() method

   546     # _aifc -- whether we're writing an AIFF-C file or an AIFF file

   547     #       set through the aifc() method, reset through the

   548     #       aiff() method

   549     #

   550     # These variables are used internally only:

   551     # _version -- the AIFF-C version number

   552     # _comp -- the compressor from builtin module cl

   553     # _nframeswritten -- the number of audio frames actually written

   554     # _datalength -- the size of the audio samples written to the header

   555     # _datawritten -- the size of the audio samples actually written

   556 

   557     def __init__(self, f):

   558         if type(f) == type(''):

   559             filename = f

   560             f = __builtin__.open(f, 'wb')

   561         else:

   562             # else, assume it is an open file object already

   563             filename = '???'

   564         self.initfp(f)

   565         if filename[-5:] == '.aiff':

   566             self._aifc = 0

   567         else:

   568             self._aifc = 1

   569 

   570     def initfp(self, file):

   571         self._file = file

   572         self._version = _AIFC_version

   573         self._comptype = 'NONE'

   574         self._compname = 'not compressed'

   575         self._comp = None

   576         self._convert = None

   577         self._nchannels = 0

   578         self._sampwidth = 0

   579         self._framerate = 0

   580         self._nframes = 0

   581         self._nframeswritten = 0

   582         self._datawritten = 0

   583         self._datalength = 0

   584         self._markers = []

   585         self._marklength = 0

   586         self._aifc = 1      # AIFF-C is default

   587 

   588     def __del__(self):

   589         if self._file:

   590             self.close()

   591 

   592     #

   593     # User visible methods.

   594     #

   595     def aiff(self):

   596         if self._nframeswritten:

   597             raise Error, 'cannot change parameters after starting to write'

   598         self._aifc = 0

   599 

   600     def aifc(self):

   601         if self._nframeswritten:

   602             raise Error, 'cannot change parameters after starting to write'

   603         self._aifc = 1

   604 

   605     def setnchannels(self, nchannels):

   606         if self._nframeswritten:

   607             raise Error, 'cannot change parameters after starting to write'

   608         if nchannels < 1:

   609             raise Error, 'bad # of channels'

   610         self._nchannels = nchannels

   611 

   612     def getnchannels(self):

   613         if not self._nchannels:

   614             raise Error, 'number of channels not set'

   615         return self._nchannels

   616 

   617     def setsampwidth(self, sampwidth):

   618         if self._nframeswritten:

   619             raise Error, 'cannot change parameters after starting to write'

   620         if sampwidth < 1 or sampwidth > 4:

   621             raise Error, 'bad sample width'

   622         self._sampwidth = sampwidth

   623 

   624     def getsampwidth(self):

   625         if not self._sampwidth:

   626             raise Error, 'sample width not set'

   627         return self._sampwidth

   628 

   629     def setframerate(self, framerate):

   630         if self._nframeswritten:

   631             raise Error, 'cannot change parameters after starting to write'

   632         if framerate <= 0:

   633             raise Error, 'bad frame rate'

   634         self._framerate = framerate

   635 

   636     def getframerate(self):

   637         if not self._framerate:

   638             raise Error, 'frame rate not set'

   639         return self._framerate

   640 

   641     def setnframes(self, nframes):

   642         if self._nframeswritten:

   643             raise Error, 'cannot change parameters after starting to write'

   644         self._nframes = nframes

   645 

   646     def getnframes(self):

   647         return self._nframeswritten

   648 

   649     def setcomptype(self, comptype, compname):

   650         if self._nframeswritten:

   651             raise Error, 'cannot change parameters after starting to write'

   652         if comptype not in ('NONE', 'ULAW', 'ALAW', 'G722'):

   653             raise Error, 'unsupported compression type'

   654         self._comptype = comptype

   655         self._compname = compname

   656 

   657     def getcomptype(self):

   658         return self._comptype

   659 

   660     def getcompname(self):

   661         return self._compname

   662 

   663 ##  def setversion(self, version):

   664 ##      if self._nframeswritten:

   665 ##          raise Error, 'cannot change parameters after starting to write'

   666 ##      self._version = version

   667 

   668     def setparams(self, (nchannels, sampwidth, framerate, nframes, comptype, compname)):

   669         if self._nframeswritten:

   670             raise Error, 'cannot change parameters after starting to write'

   671         if comptype not in ('NONE', 'ULAW', 'ALAW', 'G722'):

   672             raise Error, 'unsupported compression type'

   673         self.setnchannels(nchannels)

   674         self.setsampwidth(sampwidth)

   675         self.setframerate(framerate)

   676         self.setnframes(nframes)

   677         self.setcomptype(comptype, compname)

   678 

   679     def getparams(self):

   680         if not self._nchannels or not self._sampwidth or not self._framerate:

   681             raise Error, 'not all parameters set'

   682         return self._nchannels, self._sampwidth, self._framerate, \

   683               self._nframes, self._comptype, self._compname

   684 

   685     def setmark(self, id, pos, name):

   686         if id <= 0:

   687             raise Error, 'marker ID must be > 0'

   688         if pos < 0:

   689             raise Error, 'marker position must be >= 0'

   690         if type(name) != type(''):

   691             raise Error, 'marker name must be a string'

   692         for i in range(len(self._markers)):

   693             if id == self._markers[i][0]:

   694                 self._markers[i] = id, pos, name

   695                 return

   696         self._markers.append((id, pos, name))

   697 

   698     def getmark(self, id):

   699         for marker in self._markers:

   700             if id == marker[0]:

   701                 return marker

   702         raise Error, 'marker %r does not exist' % (id,)

   703 

   704     def getmarkers(self):

   705         if len(self._markers) == 0:

   706             return None

   707         return self._markers

   708 

   709     def tell(self):

   710         return self._nframeswritten

   711 

   712     def writeframesraw(self, data):

   713         self._ensure_header_written(len(data))

   714         nframes = len(data) / (self._sampwidth * self._nchannels)

   715         if self._convert:

   716             data = self._convert(data)

   717         self._file.write(data)

   718         self._nframeswritten = self._nframeswritten + nframes

   719         self._datawritten = self._datawritten + len(data)

   720 

   721     def writeframes(self, data):

   722         self.writeframesraw(data)

   723         if self._nframeswritten != self._nframes or \

   724               self._datalength != self._datawritten:

   725             self._patchheader()

   726 

   727     def close(self):

   728         self._ensure_header_written(0)

   729         if self._datawritten & 1:

   730             # quick pad to even size

   731             self._file.write(chr(0))

   732             self._datawritten = self._datawritten + 1

   733         self._writemarkers()

   734         if self._nframeswritten != self._nframes or \

   735               self._datalength != self._datawritten or \

   736               self._marklength:

   737             self._patchheader()

   738         if self._comp:

   739             self._comp.CloseCompressor()

   740             self._comp = None

   741         self._file.flush()

   742         self._file = None

   743 

   744     #

   745     # Internal methods.

   746     #

   747 

   748     def _comp_data(self, data):

   749         import cl

   750         dummy = self._comp.SetParam(cl.FRAME_BUFFER_SIZE, len(data))

   751         dummy = self._comp.SetParam(cl.COMPRESSED_BUFFER_SIZE, len(data))

   752         return self._comp.Compress(self._nframes, data)

   753 

   754     def _lin2ulaw(self, data):

   755         import audioop

   756         return audioop.lin2ulaw(data, 2)

   757 

   758     def _lin2adpcm(self, data):

   759         import audioop

   760         if not hasattr(self, '_adpcmstate'):

   761             self._adpcmstate = None

   762         data, self._adpcmstate = audioop.lin2adpcm(data, 2,

   763                                self._adpcmstate)

   764         return data

   765 

   766     def _ensure_header_written(self, datasize):

   767         if not self._nframeswritten:

   768             if self._comptype in ('ULAW', 'ALAW'):

   769                 if not self._sampwidth:

   770                     self._sampwidth = 2

   771                 if self._sampwidth != 2:

   772                     raise Error, 'sample width must be 2 when compressing with ULAW or ALAW'

   773             if self._comptype == 'G722':

   774                 if not self._sampwidth:

   775                     self._sampwidth = 2

   776                 if self._sampwidth != 2:

   777                     raise Error, 'sample width must be 2 when compressing with G7.22 (ADPCM)'

   778             if not self._nchannels:

   779                 raise Error, '# channels not specified'

   780             if not self._sampwidth:

   781                 raise Error, 'sample width not specified'

   782             if not self._framerate:

   783                 raise Error, 'sampling rate not specified'

   784             self._write_header(datasize)

   785 

   786     def _init_compression(self):

   787         if self._comptype == 'G722':

   788             self._convert = self._lin2adpcm

   789             return

   790         try:

   791             import cl

   792         except ImportError:

   793             if self._comptype == 'ULAW':

   794                 try:

   795                     import audioop

   796                     self._convert = self._lin2ulaw

   797                     return

   798                 except ImportError:

   799                     pass

   800             raise Error, 'cannot write compressed AIFF-C files'

   801         if self._comptype == 'ULAW':

   802             scheme = cl.G711_ULAW

   803         elif self._comptype == 'ALAW':

   804             scheme = cl.G711_ALAW

   805         else:

   806             raise Error, 'unsupported compression type'

   807         self._comp = cl.OpenCompressor(scheme)

   808         params = [cl.ORIGINAL_FORMAT, 0,

   809               cl.BITS_PER_COMPONENT, self._sampwidth * 8,

   810               cl.FRAME_RATE, self._framerate,

   811               cl.FRAME_BUFFER_SIZE, 100,

   812               cl.COMPRESSED_BUFFER_SIZE, 100]

   813         if self._nchannels == 1:

   814             params[1] = cl.MONO

   815         elif self._nchannels == 2:

   816             params[1] = cl.STEREO_INTERLEAVED

   817         else:

   818             raise Error, 'cannot compress more than 2 channels'

   819         self._comp.SetParams(params)

   820         # the compressor produces a header which we ignore

   821         dummy = self._comp.Compress(0, '')

   822         self._convert = self._comp_data

   823 

   824     def _write_header(self, initlength):

   825         if self._aifc and self._comptype != 'NONE':

   826             self._init_compression()

   827         self._file.write('FORM')

   828         if not self._nframes:

   829             self._nframes = initlength / (self._nchannels * self._sampwidth)

   830         self._datalength = self._nframes * self._nchannels * self._sampwidth

   831         if self._datalength & 1:

   832             self._datalength = self._datalength + 1

   833         if self._aifc:

   834             if self._comptype in ('ULAW', 'ALAW'):

   835                 self._datalength = self._datalength / 2

   836                 if self._datalength & 1:

   837                     self._datalength = self._datalength + 1

   838             elif self._comptype == 'G722':

   839                 self._datalength = (self._datalength + 3) / 4

   840                 if self._datalength & 1:

   841                     self._datalength = self._datalength + 1

   842         self._form_length_pos = self._file.tell()

   843         commlength = self._write_form_length(self._datalength)

   844         if self._aifc:

   845             self._file.write('AIFC')

   846             self._file.write('FVER')

   847             _write_long(self._file, 4)

   848             _write_long(self._file, self._version)

   849         else:

   850             self._file.write('AIFF')

   851         self._file.write('COMM')

   852         _write_long(self._file, commlength)

   853         _write_short(self._file, self._nchannels)

   854         self._nframes_pos = self._file.tell()

   855         _write_long(self._file, self._nframes)

   856         _write_short(self._file, self._sampwidth * 8)

   857         _write_float(self._file, self._framerate)

   858         if self._aifc:

   859             self._file.write(self._comptype)

   860             _write_string(self._file, self._compname)

   861         self._file.write('SSND')

   862         self._ssnd_length_pos = self._file.tell()

   863         _write_long(self._file, self._datalength + 8)

   864         _write_long(self._file, 0)

   865         _write_long(self._file, 0)

   866 

   867     def _write_form_length(self, datalength):

   868         if self._aifc:

   869             commlength = 18 + 5 + len(self._compname)

   870             if commlength & 1:

   871                 commlength = commlength + 1

   872             verslength = 12

   873         else:

   874             commlength = 18

   875             verslength = 0

   876         _write_long(self._file, 4 + verslength + self._marklength + \

   877                     8 + commlength + 16 + datalength)

   878         return commlength

   879 

   880     def _patchheader(self):

   881         curpos = self._file.tell()

   882         if self._datawritten & 1:

   883             datalength = self._datawritten + 1

   884             self._file.write(chr(0))

   885         else:

   886             datalength = self._datawritten

   887         if datalength == self._datalength and \

   888               self._nframes == self._nframeswritten and \

   889               self._marklength == 0:

   890             self._file.seek(curpos, 0)

   891             return

   892         self._file.seek(self._form_length_pos, 0)

   893         dummy = self._write_form_length(datalength)

   894         self._file.seek(self._nframes_pos, 0)

   895         _write_long(self._file, self._nframeswritten)

   896         self._file.seek(self._ssnd_length_pos, 0)

   897         _write_long(self._file, datalength + 8)

   898         self._file.seek(curpos, 0)

   899         self._nframes = self._nframeswritten

   900         self._datalength = datalength

   901 

   902     def _writemarkers(self):

   903         if len(self._markers) == 0:

   904             return

   905         self._file.write('MARK')

   906         length = 2

   907         for marker in self._markers:

   908             id, pos, name = marker

   909             length = length + len(name) + 1 + 6

   910             if len(name) & 1 == 0:

   911                 length = length + 1

   912         _write_long(self._file, length)

   913         self._marklength = length + 8

   914         _write_short(self._file, len(self._markers))

   915         for marker in self._markers:

   916             id, pos, name = marker

   917             _write_short(self._file, id)

   918             _write_long(self._file, pos)

   919             _write_string(self._file, name)

   920 

   921 def open(f, mode=None):

   922     if mode is None:

   923         if hasattr(f, 'mode'):

   924             mode = f.mode

   925         else:

   926             mode = 'rb'

   927     if mode in ('r', 'rb'):

   928         return Aifc_read(f)

   929     elif mode in ('w', 'wb'):

   930         return Aifc_write(f)

   931     else:

   932         raise Error, "mode must be 'r', 'rb', 'w', or 'wb'"

   933 

   934 openfp = open # B/W compatibility

   935 

   936 if __name__ == '__main__':

   937     import sys

   938     if not sys.argv[1:]:

   939         sys.argv.append('/usr/demos/data/audio/bach.aiff')

   940     fn = sys.argv[1]

   941     f = open(fn, 'r')

   942     print "Reading", fn

   943     print "nchannels =", f.getnchannels()

   944     print "nframes   =", f.getnframes()

   945     print "sampwidth =", f.getsampwidth()

   946     print "framerate =", f.getframerate()

   947     print "comptype  =", f.getcomptype()

   948     print "compname  =", f.getcompname()

   949     if sys.argv[2:]:

   950         gn = sys.argv[2]

   951         print "Writing", gn

   952         g = open(gn, 'w')

   953         g.setparams(f.getparams())

   954         while 1:

   955             data = f.readframes(1024)

   956             if not data:

   957                 break

   958             g.writeframes(data)

   959         g.close()

   960         f.close()

   961         print "Done."