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, info):

   669         nchannels, sampwidth, framerate, nframes, comptype, compname = info

   670         if self._nframeswritten:

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

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

   673             raise Error, 'unsupported compression type'

   674         self.setnchannels(nchannels)

   675         self.setsampwidth(sampwidth)

   676         self.setframerate(framerate)

   677         self.setnframes(nframes)

   678         self.setcomptype(comptype, compname)

   679 

   680     def getparams(self):

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

   682             raise Error, 'not all parameters set'

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

   684               self._nframes, self._comptype, self._compname

   685 

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

   687         if id <= 0:

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

   689         if pos < 0:

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

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

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

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

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

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

   696                 return

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

   698 

   699     def getmark(self, id):

   700         for marker in self._markers:

   701             if id == marker[0]:

   702                 return marker

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

   704 

   705     def getmarkers(self):

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

   707             return None

   708         return self._markers

   709 

   710     def tell(self):

   711         return self._nframeswritten

   712 

   713     def writeframesraw(self, data):

   714         self._ensure_header_written(len(data))

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

   716         if self._convert:

   717             data = self._convert(data)

   718         self._file.write(data)

   719         self._nframeswritten = self._nframeswritten + nframes

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

   721 

   722     def writeframes(self, data):

   723         self.writeframesraw(data)

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

   725               self._datalength != self._datawritten:

   726             self._patchheader()

   727 

   728     def close(self):

   729         self._ensure_header_written(0)

   730         if self._datawritten & 1:

   731             # quick pad to even size

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

   733             self._datawritten = self._datawritten + 1

   734         self._writemarkers()

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

   736               self._datalength != self._datawritten or \

   737               self._marklength:

   738             self._patchheader()

   739         if self._comp:

   740             self._comp.CloseCompressor()

   741             self._comp = None

   742         self._file.flush()

   743         self._file = None

   744 

   745     #

   746     # Internal methods.

   747     #

   748 

   749     def _comp_data(self, data):

   750         import cl

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

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

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

   754 

   755     def _lin2ulaw(self, data):

   756         import audioop

   757         return audioop.lin2ulaw(data, 2)

   758 

   759     def _lin2adpcm(self, data):

   760         import audioop

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

   762             self._adpcmstate = None

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

   764                                self._adpcmstate)

   765         return data

   766 

   767     def _ensure_header_written(self, datasize):

   768         if not self._nframeswritten:

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

   770                 if not self._sampwidth:

   771                     self._sampwidth = 2

   772                 if self._sampwidth != 2:

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

   774             if self._comptype == 'G722':

   775                 if not self._sampwidth:

   776                     self._sampwidth = 2

   777                 if self._sampwidth != 2:

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

   779             if not self._nchannels:

   780                 raise Error, '# channels not specified'

   781             if not self._sampwidth:

   782                 raise Error, 'sample width not specified'

   783             if not self._framerate:

   784                 raise Error, 'sampling rate not specified'

   785             self._write_header(datasize)

   786 

   787     def _init_compression(self):

   788         if self._comptype == 'G722':

   789             self._convert = self._lin2adpcm

   790             return

   791         try:

   792             import cl

   793         except ImportError:

   794             if self._comptype == 'ULAW':

   795                 try:

   796                     import audioop

   797                     self._convert = self._lin2ulaw

   798                     return

   799                 except ImportError:

   800                     pass

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

   802         if self._comptype == 'ULAW':

   803             scheme = cl.G711_ULAW

   804         elif self._comptype == 'ALAW':

   805             scheme = cl.G711_ALAW

   806         else:

   807             raise Error, 'unsupported compression type'

   808         self._comp = cl.OpenCompressor(scheme)

   809         params = [cl.ORIGINAL_FORMAT, 0,

   810               cl.BITS_PER_COMPONENT, self._sampwidth * 8,

   811               cl.FRAME_RATE, self._framerate,

   812               cl.FRAME_BUFFER_SIZE, 100,

   813               cl.COMPRESSED_BUFFER_SIZE, 100]

   814         if self._nchannels == 1:

   815             params[1] = cl.MONO

   816         elif self._nchannels == 2:

   817             params[1] = cl.STEREO_INTERLEAVED

   818         else:

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

   820         self._comp.SetParams(params)

   821         # the compressor produces a header which we ignore

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

   823         self._convert = self._comp_data

   824 

   825     def _write_header(self, initlength):

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

   827             self._init_compression()

   828         self._file.write('FORM')

   829         if not self._nframes:

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

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

   832         if self._datalength & 1:

   833             self._datalength = self._datalength + 1

   834         if self._aifc:

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

   836                 self._datalength = self._datalength / 2

   837                 if self._datalength & 1:

   838                     self._datalength = self._datalength + 1

   839             elif self._comptype == 'G722':

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

   841                 if self._datalength & 1:

   842                     self._datalength = self._datalength + 1

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

   844         commlength = self._write_form_length(self._datalength)

   845         if self._aifc:

   846             self._file.write('AIFC')

   847             self._file.write('FVER')

   848             _write_long(self._file, 4)

   849             _write_long(self._file, self._version)

   850         else:

   851             self._file.write('AIFF')

   852         self._file.write('COMM')

   853         _write_long(self._file, commlength)

   854         _write_short(self._file, self._nchannels)

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

   856         _write_long(self._file, self._nframes)

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

   858         _write_float(self._file, self._framerate)

   859         if self._aifc:

   860             self._file.write(self._comptype)

   861             _write_string(self._file, self._compname)

   862         self._file.write('SSND')

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

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

   865         _write_long(self._file, 0)

   866         _write_long(self._file, 0)

   867 

   868     def _write_form_length(self, datalength):

   869         if self._aifc:

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

   871             if commlength & 1:

   872                 commlength = commlength + 1

   873             verslength = 12

   874         else:

   875             commlength = 18

   876             verslength = 0

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

   878                     8 + commlength + 16 + datalength)

   879         return commlength

   880 

   881     def _patchheader(self):

   882         curpos = self._file.tell()

   883         if self._datawritten & 1:

   884             datalength = self._datawritten + 1

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

   886         else:

   887             datalength = self._datawritten

   888         if datalength == self._datalength and \

   889               self._nframes == self._nframeswritten and \

   890               self._marklength == 0:

   891             self._file.seek(curpos, 0)

   892             return

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

   894         dummy = self._write_form_length(datalength)

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

   896         _write_long(self._file, self._nframeswritten)

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

   898         _write_long(self._file, datalength + 8)

   899         self._file.seek(curpos, 0)

   900         self._nframes = self._nframeswritten

   901         self._datalength = datalength

   902 

   903     def _writemarkers(self):

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

   905             return

   906         self._file.write('MARK')

   907         length = 2

   908         for marker in self._markers:

   909             id, pos, name = marker

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

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

   912                 length = length + 1

   913         _write_long(self._file, length)

   914         self._marklength = length + 8

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

   916         for marker in self._markers:

   917             id, pos, name = marker

   918             _write_short(self._file, id)

   919             _write_long(self._file, pos)

   920             _write_string(self._file, name)

   921 

   922 def open(f, mode=None):

   923     if mode is None:

   924         if hasattr(f, 'mode'):

   925             mode = f.mode

   926         else:

   927             mode = 'rb'

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

   929         return Aifc_read(f)

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

   931         return Aifc_write(f)

   932     else:

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

   934 

   935 openfp = open # B/W compatibility

   936 

   937 if __name__ == '__main__':

   938     import sys

   939     if not sys.argv[1:]:

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

   941     fn = sys.argv[1]

   942     f = open(fn, 'r')

   943     print "Reading", fn

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

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

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

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

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

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

   950     if sys.argv[2:]:

   951         gn = sys.argv[2]

   952         print "Writing", gn

   953         g = open(gn, 'w')

   954         g.setparams(f.getparams())

   955         while 1:

   956             data = f.readframes(1024)

   957             if not data:

   958                 break

   959             g.writeframes(data)

   960         g.close()

   961         f.close()

   962         print "Done."