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, you 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 | def _read_long(file): |
---|
148 | try: |
---|
149 | return struct.unpack('>l', file.read(4))[0] |
---|
150 | except struct.error: |
---|
151 | raise EOFError |
---|
152 | |
---|
153 | def _read_ulong(file): |
---|
154 | try: |
---|
155 | return struct.unpack('>L', file.read(4))[0] |
---|
156 | except struct.error: |
---|
157 | raise EOFError |
---|
158 | |
---|
159 | def _read_short(file): |
---|
160 | try: |
---|
161 | return struct.unpack('>h', file.read(2))[0] |
---|
162 | except struct.error: |
---|
163 | raise EOFError |
---|
164 | |
---|
165 | def _read_ushort(file): |
---|
166 | try: |
---|
167 | return struct.unpack('>H', file.read(2))[0] |
---|
168 | except struct.error: |
---|
169 | raise EOFError |
---|
170 | |
---|
171 | def _read_string(file): |
---|
172 | length = ord(file.read(1)) |
---|
173 | if length == 0: |
---|
174 | data = '' |
---|
175 | else: |
---|
176 | data = file.read(length) |
---|
177 | if length & 1 == 0: |
---|
178 | dummy = file.read(1) |
---|
179 | return data |
---|
180 | |
---|
181 | _HUGE_VAL = 1.79769313486231e+308 # See <limits.h> |
---|
182 | |
---|
183 | def _read_float(f): # 10 bytes |
---|
184 | expon = _read_short(f) # 2 bytes |
---|
185 | sign = 1 |
---|
186 | if expon < 0: |
---|
187 | sign = -1 |
---|
188 | expon = expon + 0x8000 |
---|
189 | himant = _read_ulong(f) # 4 bytes |
---|
190 | lomant = _read_ulong(f) # 4 bytes |
---|
191 | if expon == himant == lomant == 0: |
---|
192 | f = 0.0 |
---|
193 | elif expon == 0x7FFF: |
---|
194 | f = _HUGE_VAL |
---|
195 | else: |
---|
196 | expon = expon - 16383 |
---|
197 | f = (himant * 0x100000000L + lomant) * pow(2.0, expon - 63) |
---|
198 | return sign * f |
---|
199 | |
---|
200 | def _write_short(f, x): |
---|
201 | f.write(struct.pack('>h', x)) |
---|
202 | |
---|
203 | def _write_ushort(f, x): |
---|
204 | f.write(struct.pack('>H', x)) |
---|
205 | |
---|
206 | def _write_long(f, x): |
---|
207 | f.write(struct.pack('>l', x)) |
---|
208 | |
---|
209 | def _write_ulong(f, x): |
---|
210 | f.write(struct.pack('>L', x)) |
---|
211 | |
---|
212 | def _write_string(f, s): |
---|
213 | if len(s) > 255: |
---|
214 | raise ValueError("string exceeds maximum pstring length") |
---|
215 | f.write(struct.pack('B', len(s))) |
---|
216 | f.write(s) |
---|
217 | if len(s) & 1 == 0: |
---|
218 | f.write(chr(0)) |
---|
219 | |
---|
220 | def _write_float(f, x): |
---|
221 | import math |
---|
222 | if x < 0: |
---|
223 | sign = 0x8000 |
---|
224 | x = x * -1 |
---|
225 | else: |
---|
226 | sign = 0 |
---|
227 | if x == 0: |
---|
228 | expon = 0 |
---|
229 | himant = 0 |
---|
230 | lomant = 0 |
---|
231 | else: |
---|
232 | fmant, expon = math.frexp(x) |
---|
233 | if expon > 16384 or fmant >= 1 or fmant != fmant: # Infinity or NaN |
---|
234 | expon = sign|0x7FFF |
---|
235 | himant = 0 |
---|
236 | lomant = 0 |
---|
237 | else: # Finite |
---|
238 | expon = expon + 16382 |
---|
239 | if expon < 0: # denormalized |
---|
240 | fmant = math.ldexp(fmant, expon) |
---|
241 | expon = 0 |
---|
242 | expon = expon | sign |
---|
243 | fmant = math.ldexp(fmant, 32) |
---|
244 | fsmant = math.floor(fmant) |
---|
245 | himant = long(fsmant) |
---|
246 | fmant = math.ldexp(fmant - fsmant, 32) |
---|
247 | fsmant = math.floor(fmant) |
---|
248 | lomant = long(fsmant) |
---|
249 | _write_ushort(f, expon) |
---|
250 | _write_ulong(f, himant) |
---|
251 | _write_ulong(f, lomant) |
---|
252 | |
---|
253 | from chunk import Chunk |
---|
254 | |
---|
255 | class Aifc_read: |
---|
256 | # Variables used in this class: |
---|
257 | # |
---|
258 | # These variables are available to the user though appropriate |
---|
259 | # methods of this class: |
---|
260 | # _file -- the open file with methods read(), close(), and seek() |
---|
261 | # set through the __init__() method |
---|
262 | # _nchannels -- the number of audio channels |
---|
263 | # available through the getnchannels() method |
---|
264 | # _nframes -- the number of audio frames |
---|
265 | # available through the getnframes() method |
---|
266 | # _sampwidth -- the number of bytes per audio sample |
---|
267 | # available through the getsampwidth() method |
---|
268 | # _framerate -- the sampling frequency |
---|
269 | # available through the getframerate() method |
---|
270 | # _comptype -- the AIFF-C compression type ('NONE' if AIFF) |
---|
271 | # available through the getcomptype() method |
---|
272 | # _compname -- the human-readable AIFF-C compression type |
---|
273 | # available through the getcomptype() method |
---|
274 | # _markers -- the marks in the audio file |
---|
275 | # available through the getmarkers() and getmark() |
---|
276 | # methods |
---|
277 | # _soundpos -- the position in the audio stream |
---|
278 | # available through the tell() method, set through the |
---|
279 | # setpos() method |
---|
280 | # |
---|
281 | # These variables are used internally only: |
---|
282 | # _version -- the AIFF-C version number |
---|
283 | # _decomp -- the decompressor from builtin module cl |
---|
284 | # _comm_chunk_read -- 1 iff the COMM chunk has been read |
---|
285 | # _aifc -- 1 iff reading an AIFF-C file |
---|
286 | # _ssnd_seek_needed -- 1 iff positioned correctly in audio |
---|
287 | # file for readframes() |
---|
288 | # _ssnd_chunk -- instantiation of a chunk class for the SSND chunk |
---|
289 | # _framesize -- size of one frame in the file |
---|
290 | |
---|
291 | def initfp(self, file): |
---|
292 | self._version = 0 |
---|
293 | self._decomp = None |
---|
294 | self._convert = None |
---|
295 | self._markers = [] |
---|
296 | self._soundpos = 0 |
---|
297 | self._file = file |
---|
298 | chunk = Chunk(file) |
---|
299 | if chunk.getname() != 'FORM': |
---|
300 | raise Error, 'file does not start with FORM id' |
---|
301 | formdata = chunk.read(4) |
---|
302 | if formdata == 'AIFF': |
---|
303 | self._aifc = 0 |
---|
304 | elif formdata == 'AIFC': |
---|
305 | self._aifc = 1 |
---|
306 | else: |
---|
307 | raise Error, 'not an AIFF or AIFF-C file' |
---|
308 | self._comm_chunk_read = 0 |
---|
309 | while 1: |
---|
310 | self._ssnd_seek_needed = 1 |
---|
311 | try: |
---|
312 | chunk = Chunk(self._file) |
---|
313 | except EOFError: |
---|
314 | break |
---|
315 | chunkname = chunk.getname() |
---|
316 | if chunkname == 'COMM': |
---|
317 | self._read_comm_chunk(chunk) |
---|
318 | self._comm_chunk_read = 1 |
---|
319 | elif chunkname == 'SSND': |
---|
320 | self._ssnd_chunk = chunk |
---|
321 | dummy = chunk.read(8) |
---|
322 | self._ssnd_seek_needed = 0 |
---|
323 | elif chunkname == 'FVER': |
---|
324 | self._version = _read_ulong(chunk) |
---|
325 | elif chunkname == 'MARK': |
---|
326 | self._readmark(chunk) |
---|
327 | chunk.skip() |
---|
328 | if not self._comm_chunk_read or not self._ssnd_chunk: |
---|
329 | raise Error, 'COMM chunk and/or SSND chunk missing' |
---|
330 | if self._aifc and self._decomp: |
---|
331 | import cl |
---|
332 | params = [cl.ORIGINAL_FORMAT, 0, |
---|
333 | cl.BITS_PER_COMPONENT, self._sampwidth * 8, |
---|
334 | cl.FRAME_RATE, self._framerate] |
---|
335 | if self._nchannels == 1: |
---|
336 | params[1] = cl.MONO |
---|
337 | elif self._nchannels == 2: |
---|
338 | params[1] = cl.STEREO_INTERLEAVED |
---|
339 | else: |
---|
340 | raise Error, 'cannot compress more than 2 channels' |
---|
341 | self._decomp.SetParams(params) |
---|
342 | |
---|
343 | def __init__(self, f): |
---|
344 | if type(f) == type(''): |
---|
345 | f = __builtin__.open(f, 'rb') |
---|
346 | # else, assume it is an open file object already |
---|
347 | self.initfp(f) |
---|
348 | |
---|
349 | # |
---|
350 | # User visible methods. |
---|
351 | # |
---|
352 | def getfp(self): |
---|
353 | return self._file |
---|
354 | |
---|
355 | def rewind(self): |
---|
356 | self._ssnd_seek_needed = 1 |
---|
357 | self._soundpos = 0 |
---|
358 | |
---|
359 | def close(self): |
---|
360 | decomp = self._decomp |
---|
361 | try: |
---|
362 | if decomp: |
---|
363 | self._decomp = None |
---|
364 | decomp.CloseDecompressor() |
---|
365 | finally: |
---|
366 | self._file.close() |
---|
367 | |
---|
368 | def tell(self): |
---|
369 | return self._soundpos |
---|
370 | |
---|
371 | def getnchannels(self): |
---|
372 | return self._nchannels |
---|
373 | |
---|
374 | def getnframes(self): |
---|
375 | return self._nframes |
---|
376 | |
---|
377 | def getsampwidth(self): |
---|
378 | return self._sampwidth |
---|
379 | |
---|
380 | def getframerate(self): |
---|
381 | return self._framerate |
---|
382 | |
---|
383 | def getcomptype(self): |
---|
384 | return self._comptype |
---|
385 | |
---|
386 | def getcompname(self): |
---|
387 | return self._compname |
---|
388 | |
---|
389 | ## def getversion(self): |
---|
390 | ## return self._version |
---|
391 | |
---|
392 | def getparams(self): |
---|
393 | return self.getnchannels(), self.getsampwidth(), \ |
---|
394 | self.getframerate(), self.getnframes(), \ |
---|
395 | self.getcomptype(), self.getcompname() |
---|
396 | |
---|
397 | def getmarkers(self): |
---|
398 | if len(self._markers) == 0: |
---|
399 | return None |
---|
400 | return self._markers |
---|
401 | |
---|
402 | def getmark(self, id): |
---|
403 | for marker in self._markers: |
---|
404 | if id == marker[0]: |
---|
405 | return marker |
---|
406 | raise Error, 'marker %r does not exist' % (id,) |
---|
407 | |
---|
408 | def setpos(self, pos): |
---|
409 | if pos < 0 or pos > self._nframes: |
---|
410 | raise Error, 'position not in range' |
---|
411 | self._soundpos = pos |
---|
412 | self._ssnd_seek_needed = 1 |
---|
413 | |
---|
414 | def readframes(self, nframes): |
---|
415 | if self._ssnd_seek_needed: |
---|
416 | self._ssnd_chunk.seek(0) |
---|
417 | dummy = self._ssnd_chunk.read(8) |
---|
418 | pos = self._soundpos * self._framesize |
---|
419 | if pos: |
---|
420 | self._ssnd_chunk.seek(pos + 8) |
---|
421 | self._ssnd_seek_needed = 0 |
---|
422 | if nframes == 0: |
---|
423 | return '' |
---|
424 | data = self._ssnd_chunk.read(nframes * self._framesize) |
---|
425 | if self._convert and data: |
---|
426 | data = self._convert(data) |
---|
427 | self._soundpos = self._soundpos + len(data) // (self._nchannels * self._sampwidth) |
---|
428 | return data |
---|
429 | |
---|
430 | # |
---|
431 | # Internal methods. |
---|
432 | # |
---|
433 | |
---|
434 | def _decomp_data(self, data): |
---|
435 | import cl |
---|
436 | dummy = self._decomp.SetParam(cl.FRAME_BUFFER_SIZE, |
---|
437 | len(data) * 2) |
---|
438 | return self._decomp.Decompress(len(data) // self._nchannels, |
---|
439 | data) |
---|
440 | |
---|
441 | def _ulaw2lin(self, data): |
---|
442 | import audioop |
---|
443 | return audioop.ulaw2lin(data, 2) |
---|
444 | |
---|
445 | def _adpcm2lin(self, data): |
---|
446 | import audioop |
---|
447 | if not hasattr(self, '_adpcmstate'): |
---|
448 | # first time |
---|
449 | self._adpcmstate = None |
---|
450 | data, self._adpcmstate = audioop.adpcm2lin(data, 2, |
---|
451 | self._adpcmstate) |
---|
452 | return data |
---|
453 | |
---|
454 | def _read_comm_chunk(self, chunk): |
---|
455 | self._nchannels = _read_short(chunk) |
---|
456 | self._nframes = _read_long(chunk) |
---|
457 | self._sampwidth = (_read_short(chunk) + 7) // 8 |
---|
458 | self._framerate = int(_read_float(chunk)) |
---|
459 | self._framesize = self._nchannels * self._sampwidth |
---|
460 | if self._aifc: |
---|
461 | #DEBUG: SGI's soundeditor produces a bad size :-( |
---|
462 | kludge = 0 |
---|
463 | if chunk.chunksize == 18: |
---|
464 | kludge = 1 |
---|
465 | print 'Warning: bad COMM chunk size' |
---|
466 | chunk.chunksize = 23 |
---|
467 | #DEBUG end |
---|
468 | self._comptype = chunk.read(4) |
---|
469 | #DEBUG start |
---|
470 | if kludge: |
---|
471 | length = ord(chunk.file.read(1)) |
---|
472 | if length & 1 == 0: |
---|
473 | length = length + 1 |
---|
474 | chunk.chunksize = chunk.chunksize + length |
---|
475 | chunk.file.seek(-1, 1) |
---|
476 | #DEBUG end |
---|
477 | self._compname = _read_string(chunk) |
---|
478 | if self._comptype != 'NONE': |
---|
479 | if self._comptype == 'G722': |
---|
480 | try: |
---|
481 | import audioop |
---|
482 | except ImportError: |
---|
483 | pass |
---|
484 | else: |
---|
485 | self._convert = self._adpcm2lin |
---|
486 | self._sampwidth = 2 |
---|
487 | return |
---|
488 | # for ULAW and ALAW try Compression Library |
---|
489 | try: |
---|
490 | import cl |
---|
491 | except ImportError: |
---|
492 | if self._comptype in ('ULAW', 'ulaw'): |
---|
493 | try: |
---|
494 | import audioop |
---|
495 | self._convert = self._ulaw2lin |
---|
496 | self._sampwidth = 2 |
---|
497 | return |
---|
498 | except ImportError: |
---|
499 | pass |
---|
500 | raise Error, 'cannot read compressed AIFF-C files' |
---|
501 | if self._comptype in ('ULAW', 'ulaw'): |
---|
502 | scheme = cl.G711_ULAW |
---|
503 | elif self._comptype in ('ALAW', 'alaw'): |
---|
504 | scheme = cl.G711_ALAW |
---|
505 | else: |
---|
506 | raise Error, 'unsupported compression type' |
---|
507 | self._decomp = cl.OpenDecompressor(scheme) |
---|
508 | self._convert = self._decomp_data |
---|
509 | self._sampwidth = 2 |
---|
510 | else: |
---|
511 | self._comptype = 'NONE' |
---|
512 | self._compname = 'not compressed' |
---|
513 | |
---|
514 | def _readmark(self, chunk): |
---|
515 | nmarkers = _read_short(chunk) |
---|
516 | # Some files appear to contain invalid counts. |
---|
517 | # Cope with this by testing for EOF. |
---|
518 | try: |
---|
519 | for i in range(nmarkers): |
---|
520 | id = _read_short(chunk) |
---|
521 | pos = _read_long(chunk) |
---|
522 | name = _read_string(chunk) |
---|
523 | if pos or name: |
---|
524 | # some files appear to have |
---|
525 | # dummy markers consisting of |
---|
526 | # a position 0 and name '' |
---|
527 | self._markers.append((id, pos, name)) |
---|
528 | except EOFError: |
---|
529 | print 'Warning: MARK chunk contains only', |
---|
530 | print len(self._markers), |
---|
531 | if len(self._markers) == 1: print 'marker', |
---|
532 | else: print 'markers', |
---|
533 | print 'instead of', nmarkers |
---|
534 | |
---|
535 | class Aifc_write: |
---|
536 | # Variables used in this class: |
---|
537 | # |
---|
538 | # These variables are user settable through appropriate methods |
---|
539 | # of this class: |
---|
540 | # _file -- the open file with methods write(), close(), tell(), seek() |
---|
541 | # set through the __init__() method |
---|
542 | # _comptype -- the AIFF-C compression type ('NONE' in AIFF) |
---|
543 | # set through the setcomptype() or setparams() method |
---|
544 | # _compname -- the human-readable AIFF-C compression type |
---|
545 | # set through the setcomptype() or setparams() method |
---|
546 | # _nchannels -- the number of audio channels |
---|
547 | # set through the setnchannels() or setparams() method |
---|
548 | # _sampwidth -- the number of bytes per audio sample |
---|
549 | # set through the setsampwidth() or setparams() method |
---|
550 | # _framerate -- the sampling frequency |
---|
551 | # set through the setframerate() or setparams() method |
---|
552 | # _nframes -- the number of audio frames written to the header |
---|
553 | # set through the setnframes() or setparams() method |
---|
554 | # _aifc -- whether we're writing an AIFF-C file or an AIFF file |
---|
555 | # set through the aifc() method, reset through the |
---|
556 | # aiff() method |
---|
557 | # |
---|
558 | # These variables are used internally only: |
---|
559 | # _version -- the AIFF-C version number |
---|
560 | # _comp -- the compressor from builtin module cl |
---|
561 | # _nframeswritten -- the number of audio frames actually written |
---|
562 | # _datalength -- the size of the audio samples written to the header |
---|
563 | # _datawritten -- the size of the audio samples actually written |
---|
564 | |
---|
565 | def __init__(self, f): |
---|
566 | if type(f) == type(''): |
---|
567 | filename = f |
---|
568 | f = __builtin__.open(f, 'wb') |
---|
569 | else: |
---|
570 | # else, assume it is an open file object already |
---|
571 | filename = '???' |
---|
572 | self.initfp(f) |
---|
573 | if filename[-5:] == '.aiff': |
---|
574 | self._aifc = 0 |
---|
575 | else: |
---|
576 | self._aifc = 1 |
---|
577 | |
---|
578 | def initfp(self, file): |
---|
579 | self._file = file |
---|
580 | self._version = _AIFC_version |
---|
581 | self._comptype = 'NONE' |
---|
582 | self._compname = 'not compressed' |
---|
583 | self._comp = None |
---|
584 | self._convert = None |
---|
585 | self._nchannels = 0 |
---|
586 | self._sampwidth = 0 |
---|
587 | self._framerate = 0 |
---|
588 | self._nframes = 0 |
---|
589 | self._nframeswritten = 0 |
---|
590 | self._datawritten = 0 |
---|
591 | self._datalength = 0 |
---|
592 | self._markers = [] |
---|
593 | self._marklength = 0 |
---|
594 | self._aifc = 1 # AIFF-C is default |
---|
595 | |
---|
596 | def __del__(self): |
---|
597 | if self._file: |
---|
598 | self.close() |
---|
599 | |
---|
600 | # |
---|
601 | # User visible methods. |
---|
602 | # |
---|
603 | def aiff(self): |
---|
604 | if self._nframeswritten: |
---|
605 | raise Error, 'cannot change parameters after starting to write' |
---|
606 | self._aifc = 0 |
---|
607 | |
---|
608 | def aifc(self): |
---|
609 | if self._nframeswritten: |
---|
610 | raise Error, 'cannot change parameters after starting to write' |
---|
611 | self._aifc = 1 |
---|
612 | |
---|
613 | def setnchannels(self, nchannels): |
---|
614 | if self._nframeswritten: |
---|
615 | raise Error, 'cannot change parameters after starting to write' |
---|
616 | if nchannels < 1: |
---|
617 | raise Error, 'bad # of channels' |
---|
618 | self._nchannels = nchannels |
---|
619 | |
---|
620 | def getnchannels(self): |
---|
621 | if not self._nchannels: |
---|
622 | raise Error, 'number of channels not set' |
---|
623 | return self._nchannels |
---|
624 | |
---|
625 | def setsampwidth(self, sampwidth): |
---|
626 | if self._nframeswritten: |
---|
627 | raise Error, 'cannot change parameters after starting to write' |
---|
628 | if sampwidth < 1 or sampwidth > 4: |
---|
629 | raise Error, 'bad sample width' |
---|
630 | self._sampwidth = sampwidth |
---|
631 | |
---|
632 | def getsampwidth(self): |
---|
633 | if not self._sampwidth: |
---|
634 | raise Error, 'sample width not set' |
---|
635 | return self._sampwidth |
---|
636 | |
---|
637 | def setframerate(self, framerate): |
---|
638 | if self._nframeswritten: |
---|
639 | raise Error, 'cannot change parameters after starting to write' |
---|
640 | if framerate <= 0: |
---|
641 | raise Error, 'bad frame rate' |
---|
642 | self._framerate = framerate |
---|
643 | |
---|
644 | def getframerate(self): |
---|
645 | if not self._framerate: |
---|
646 | raise Error, 'frame rate not set' |
---|
647 | return self._framerate |
---|
648 | |
---|
649 | def setnframes(self, nframes): |
---|
650 | if self._nframeswritten: |
---|
651 | raise Error, 'cannot change parameters after starting to write' |
---|
652 | self._nframes = nframes |
---|
653 | |
---|
654 | def getnframes(self): |
---|
655 | return self._nframeswritten |
---|
656 | |
---|
657 | def setcomptype(self, comptype, compname): |
---|
658 | if self._nframeswritten: |
---|
659 | raise Error, 'cannot change parameters after starting to write' |
---|
660 | if comptype not in ('NONE', 'ULAW', 'ulaw', 'ALAW', 'alaw', 'G722'): |
---|
661 | raise Error, 'unsupported compression type' |
---|
662 | self._comptype = comptype |
---|
663 | self._compname = compname |
---|
664 | |
---|
665 | def getcomptype(self): |
---|
666 | return self._comptype |
---|
667 | |
---|
668 | def getcompname(self): |
---|
669 | return self._compname |
---|
670 | |
---|
671 | ## def setversion(self, version): |
---|
672 | ## if self._nframeswritten: |
---|
673 | ## raise Error, 'cannot change parameters after starting to write' |
---|
674 | ## self._version = version |
---|
675 | |
---|
676 | def setparams(self, info): |
---|
677 | nchannels, sampwidth, framerate, nframes, comptype, compname = info |
---|
678 | if self._nframeswritten: |
---|
679 | raise Error, 'cannot change parameters after starting to write' |
---|
680 | if comptype not in ('NONE', 'ULAW', 'ulaw', 'ALAW', 'alaw', 'G722'): |
---|
681 | raise Error, 'unsupported compression type' |
---|
682 | self.setnchannels(nchannels) |
---|
683 | self.setsampwidth(sampwidth) |
---|
684 | self.setframerate(framerate) |
---|
685 | self.setnframes(nframes) |
---|
686 | self.setcomptype(comptype, compname) |
---|
687 | |
---|
688 | def getparams(self): |
---|
689 | if not self._nchannels or not self._sampwidth or not self._framerate: |
---|
690 | raise Error, 'not all parameters set' |
---|
691 | return self._nchannels, self._sampwidth, self._framerate, \ |
---|
692 | self._nframes, self._comptype, self._compname |
---|
693 | |
---|
694 | def setmark(self, id, pos, name): |
---|
695 | if id <= 0: |
---|
696 | raise Error, 'marker ID must be > 0' |
---|
697 | if pos < 0: |
---|
698 | raise Error, 'marker position must be >= 0' |
---|
699 | if type(name) != type(''): |
---|
700 | raise Error, 'marker name must be a string' |
---|
701 | for i in range(len(self._markers)): |
---|
702 | if id == self._markers[i][0]: |
---|
703 | self._markers[i] = id, pos, name |
---|
704 | return |
---|
705 | self._markers.append((id, pos, name)) |
---|
706 | |
---|
707 | def getmark(self, id): |
---|
708 | for marker in self._markers: |
---|
709 | if id == marker[0]: |
---|
710 | return marker |
---|
711 | raise Error, 'marker %r does not exist' % (id,) |
---|
712 | |
---|
713 | def getmarkers(self): |
---|
714 | if len(self._markers) == 0: |
---|
715 | return None |
---|
716 | return self._markers |
---|
717 | |
---|
718 | def tell(self): |
---|
719 | return self._nframeswritten |
---|
720 | |
---|
721 | def writeframesraw(self, data): |
---|
722 | self._ensure_header_written(len(data)) |
---|
723 | nframes = len(data) // (self._sampwidth * self._nchannels) |
---|
724 | if self._convert: |
---|
725 | data = self._convert(data) |
---|
726 | self._file.write(data) |
---|
727 | self._nframeswritten = self._nframeswritten + nframes |
---|
728 | self._datawritten = self._datawritten + len(data) |
---|
729 | |
---|
730 | def writeframes(self, data): |
---|
731 | self.writeframesraw(data) |
---|
732 | if self._nframeswritten != self._nframes or \ |
---|
733 | self._datalength != self._datawritten: |
---|
734 | self._patchheader() |
---|
735 | |
---|
736 | def close(self): |
---|
737 | if self._file is None: |
---|
738 | return |
---|
739 | try: |
---|
740 | self._ensure_header_written(0) |
---|
741 | if self._datawritten & 1: |
---|
742 | # quick pad to even size |
---|
743 | self._file.write(chr(0)) |
---|
744 | self._datawritten = self._datawritten + 1 |
---|
745 | self._writemarkers() |
---|
746 | if self._nframeswritten != self._nframes or \ |
---|
747 | self._datalength != self._datawritten or \ |
---|
748 | self._marklength: |
---|
749 | self._patchheader() |
---|
750 | if self._comp: |
---|
751 | self._comp.CloseCompressor() |
---|
752 | self._comp = None |
---|
753 | finally: |
---|
754 | # Prevent ref cycles |
---|
755 | self._convert = None |
---|
756 | f = self._file |
---|
757 | self._file = None |
---|
758 | f.close() |
---|
759 | |
---|
760 | # |
---|
761 | # Internal methods. |
---|
762 | # |
---|
763 | |
---|
764 | def _comp_data(self, data): |
---|
765 | import cl |
---|
766 | dummy = self._comp.SetParam(cl.FRAME_BUFFER_SIZE, len(data)) |
---|
767 | dummy = self._comp.SetParam(cl.COMPRESSED_BUFFER_SIZE, len(data)) |
---|
768 | return self._comp.Compress(self._nframes, data) |
---|
769 | |
---|
770 | def _lin2ulaw(self, data): |
---|
771 | import audioop |
---|
772 | return audioop.lin2ulaw(data, 2) |
---|
773 | |
---|
774 | def _lin2adpcm(self, data): |
---|
775 | import audioop |
---|
776 | if not hasattr(self, '_adpcmstate'): |
---|
777 | self._adpcmstate = None |
---|
778 | data, self._adpcmstate = audioop.lin2adpcm(data, 2, |
---|
779 | self._adpcmstate) |
---|
780 | return data |
---|
781 | |
---|
782 | def _ensure_header_written(self, datasize): |
---|
783 | if not self._nframeswritten: |
---|
784 | if self._comptype in ('ULAW', 'ulaw', 'ALAW', 'alaw'): |
---|
785 | if not self._sampwidth: |
---|
786 | self._sampwidth = 2 |
---|
787 | if self._sampwidth != 2: |
---|
788 | raise Error, 'sample width must be 2 when compressing with ULAW or ALAW' |
---|
789 | if self._comptype == 'G722': |
---|
790 | if not self._sampwidth: |
---|
791 | self._sampwidth = 2 |
---|
792 | if self._sampwidth != 2: |
---|
793 | raise Error, 'sample width must be 2 when compressing with G7.22 (ADPCM)' |
---|
794 | if not self._nchannels: |
---|
795 | raise Error, '# channels not specified' |
---|
796 | if not self._sampwidth: |
---|
797 | raise Error, 'sample width not specified' |
---|
798 | if not self._framerate: |
---|
799 | raise Error, 'sampling rate not specified' |
---|
800 | self._write_header(datasize) |
---|
801 | |
---|
802 | def _init_compression(self): |
---|
803 | if self._comptype == 'G722': |
---|
804 | self._convert = self._lin2adpcm |
---|
805 | return |
---|
806 | try: |
---|
807 | import cl |
---|
808 | except ImportError: |
---|
809 | if self._comptype in ('ULAW', 'ulaw'): |
---|
810 | try: |
---|
811 | import audioop |
---|
812 | self._convert = self._lin2ulaw |
---|
813 | return |
---|
814 | except ImportError: |
---|
815 | pass |
---|
816 | raise Error, 'cannot write compressed AIFF-C files' |
---|
817 | if self._comptype in ('ULAW', 'ulaw'): |
---|
818 | scheme = cl.G711_ULAW |
---|
819 | elif self._comptype in ('ALAW', 'alaw'): |
---|
820 | scheme = cl.G711_ALAW |
---|
821 | else: |
---|
822 | raise Error, 'unsupported compression type' |
---|
823 | self._comp = cl.OpenCompressor(scheme) |
---|
824 | params = [cl.ORIGINAL_FORMAT, 0, |
---|
825 | cl.BITS_PER_COMPONENT, self._sampwidth * 8, |
---|
826 | cl.FRAME_RATE, self._framerate, |
---|
827 | cl.FRAME_BUFFER_SIZE, 100, |
---|
828 | cl.COMPRESSED_BUFFER_SIZE, 100] |
---|
829 | if self._nchannels == 1: |
---|
830 | params[1] = cl.MONO |
---|
831 | elif self._nchannels == 2: |
---|
832 | params[1] = cl.STEREO_INTERLEAVED |
---|
833 | else: |
---|
834 | raise Error, 'cannot compress more than 2 channels' |
---|
835 | self._comp.SetParams(params) |
---|
836 | # the compressor produces a header which we ignore |
---|
837 | dummy = self._comp.Compress(0, '') |
---|
838 | self._convert = self._comp_data |
---|
839 | |
---|
840 | def _write_header(self, initlength): |
---|
841 | if self._aifc and self._comptype != 'NONE': |
---|
842 | self._init_compression() |
---|
843 | self._file.write('FORM') |
---|
844 | if not self._nframes: |
---|
845 | self._nframes = initlength // (self._nchannels * self._sampwidth) |
---|
846 | self._datalength = self._nframes * self._nchannels * self._sampwidth |
---|
847 | if self._datalength & 1: |
---|
848 | self._datalength = self._datalength + 1 |
---|
849 | if self._aifc: |
---|
850 | if self._comptype in ('ULAW', 'ulaw', 'ALAW', 'alaw'): |
---|
851 | self._datalength = self._datalength // 2 |
---|
852 | if self._datalength & 1: |
---|
853 | self._datalength = self._datalength + 1 |
---|
854 | elif self._comptype == 'G722': |
---|
855 | self._datalength = (self._datalength + 3) // 4 |
---|
856 | if self._datalength & 1: |
---|
857 | self._datalength = self._datalength + 1 |
---|
858 | try: |
---|
859 | self._form_length_pos = self._file.tell() |
---|
860 | except (AttributeError, IOError): |
---|
861 | self._form_length_pos = None |
---|
862 | commlength = self._write_form_length(self._datalength) |
---|
863 | if self._aifc: |
---|
864 | self._file.write('AIFC') |
---|
865 | self._file.write('FVER') |
---|
866 | _write_ulong(self._file, 4) |
---|
867 | _write_ulong(self._file, self._version) |
---|
868 | else: |
---|
869 | self._file.write('AIFF') |
---|
870 | self._file.write('COMM') |
---|
871 | _write_ulong(self._file, commlength) |
---|
872 | _write_short(self._file, self._nchannels) |
---|
873 | if self._form_length_pos is not None: |
---|
874 | self._nframes_pos = self._file.tell() |
---|
875 | _write_ulong(self._file, self._nframes) |
---|
876 | if self._comptype in ('ULAW', 'ulaw', 'ALAW', 'alaw', 'G722'): |
---|
877 | _write_short(self._file, 8) |
---|
878 | else: |
---|
879 | _write_short(self._file, self._sampwidth * 8) |
---|
880 | _write_float(self._file, self._framerate) |
---|
881 | if self._aifc: |
---|
882 | self._file.write(self._comptype) |
---|
883 | _write_string(self._file, self._compname) |
---|
884 | self._file.write('SSND') |
---|
885 | if self._form_length_pos is not None: |
---|
886 | self._ssnd_length_pos = self._file.tell() |
---|
887 | _write_ulong(self._file, self._datalength + 8) |
---|
888 | _write_ulong(self._file, 0) |
---|
889 | _write_ulong(self._file, 0) |
---|
890 | |
---|
891 | def _write_form_length(self, datalength): |
---|
892 | if self._aifc: |
---|
893 | commlength = 18 + 5 + len(self._compname) |
---|
894 | if commlength & 1: |
---|
895 | commlength = commlength + 1 |
---|
896 | verslength = 12 |
---|
897 | else: |
---|
898 | commlength = 18 |
---|
899 | verslength = 0 |
---|
900 | _write_ulong(self._file, 4 + verslength + self._marklength + \ |
---|
901 | 8 + commlength + 16 + datalength) |
---|
902 | return commlength |
---|
903 | |
---|
904 | def _patchheader(self): |
---|
905 | curpos = self._file.tell() |
---|
906 | if self._datawritten & 1: |
---|
907 | datalength = self._datawritten + 1 |
---|
908 | self._file.write(chr(0)) |
---|
909 | else: |
---|
910 | datalength = self._datawritten |
---|
911 | if datalength == self._datalength and \ |
---|
912 | self._nframes == self._nframeswritten and \ |
---|
913 | self._marklength == 0: |
---|
914 | self._file.seek(curpos, 0) |
---|
915 | return |
---|
916 | self._file.seek(self._form_length_pos, 0) |
---|
917 | dummy = self._write_form_length(datalength) |
---|
918 | self._file.seek(self._nframes_pos, 0) |
---|
919 | _write_ulong(self._file, self._nframeswritten) |
---|
920 | self._file.seek(self._ssnd_length_pos, 0) |
---|
921 | _write_ulong(self._file, datalength + 8) |
---|
922 | self._file.seek(curpos, 0) |
---|
923 | self._nframes = self._nframeswritten |
---|
924 | self._datalength = datalength |
---|
925 | |
---|
926 | def _writemarkers(self): |
---|
927 | if len(self._markers) == 0: |
---|
928 | return |
---|
929 | self._file.write('MARK') |
---|
930 | length = 2 |
---|
931 | for marker in self._markers: |
---|
932 | id, pos, name = marker |
---|
933 | length = length + len(name) + 1 + 6 |
---|
934 | if len(name) & 1 == 0: |
---|
935 | length = length + 1 |
---|
936 | _write_ulong(self._file, length) |
---|
937 | self._marklength = length + 8 |
---|
938 | _write_short(self._file, len(self._markers)) |
---|
939 | for marker in self._markers: |
---|
940 | id, pos, name = marker |
---|
941 | _write_short(self._file, id) |
---|
942 | _write_ulong(self._file, pos) |
---|
943 | _write_string(self._file, name) |
---|
944 | |
---|
945 | def open(f, mode=None): |
---|
946 | if mode is None: |
---|
947 | if hasattr(f, 'mode'): |
---|
948 | mode = f.mode |
---|
949 | else: |
---|
950 | mode = 'rb' |
---|
951 | if mode in ('r', 'rb'): |
---|
952 | return Aifc_read(f) |
---|
953 | elif mode in ('w', 'wb'): |
---|
954 | return Aifc_write(f) |
---|
955 | else: |
---|
956 | raise Error, "mode must be 'r', 'rb', 'w', or 'wb'" |
---|
957 | |
---|
958 | openfp = open # B/W compatibility |
---|
959 | |
---|
960 | if __name__ == '__main__': |
---|
961 | import sys |
---|
962 | if not sys.argv[1:]: |
---|
963 | sys.argv.append('/usr/demos/data/audio/bach.aiff') |
---|
964 | fn = sys.argv[1] |
---|
965 | f = open(fn, 'r') |
---|
966 | try: |
---|
967 | print "Reading", fn |
---|
968 | print "nchannels =", f.getnchannels() |
---|
969 | print "nframes =", f.getnframes() |
---|
970 | print "sampwidth =", f.getsampwidth() |
---|
971 | print "framerate =", f.getframerate() |
---|
972 | print "comptype =", f.getcomptype() |
---|
973 | print "compname =", f.getcompname() |
---|
974 | if sys.argv[2:]: |
---|
975 | gn = sys.argv[2] |
---|
976 | print "Writing", gn |
---|
977 | g = open(gn, 'w') |
---|
978 | try: |
---|
979 | g.setparams(f.getparams()) |
---|
980 | while 1: |
---|
981 | data = f.readframes(1024) |
---|
982 | if not data: |
---|
983 | break |
---|
984 | g.writeframes(data) |
---|
985 | finally: |
---|
986 | g.close() |
---|
987 | print "Done." |
---|
988 | finally: |
---|
989 | f.close() |
---|