1 """Stuff to parse Sun and NeXT audio files. 2 3 An audio file consists of a header followed by the data. The structure 4 of the header is as follows. 5 6 +---------------+ 7 | magic word | 8 +---------------+ 9 | header size | 10 +---------------+ 11 | data size | 12 +---------------+ 13 | encoding | 14 +---------------+ 15 | sample rate | 16 +---------------+ 17 | # of channels | 18 +---------------+ 19 | info | 20 | | 21 +---------------+ 22 23 The magic word consists of the 4 characters '.snd'. Apart from the 24 info field, all header fields are 4 bytes in size. They are all 25 32-bit unsigned integers encoded in big-endian byte order. 26 27 The header size really gives the start of the data. 28 The data size is the physical size of the data. From the other 29 parameters the number of frames can be calculated. 30 The encoding gives the way in which audio samples are encoded. 31 Possible values are listed below. 32 The info field currently consists of an ASCII string giving a 33 human-readable description of the audio file. The info field is 34 padded with NUL bytes to the header size. 35 36 Usage. 37 38 Reading audio files: 39 f = sunau.open(file, 'r') 40 where file is either the name of a file or an open file pointer. 41 The open file pointer must have methods read(), seek(), and close(). 42 When the setpos() and rewind() methods are not used, the seek() 43 method is not necessary. 44 45 This returns an instance of a class with the following public methods: 46 getnchannels() -- returns number of audio channels (1 for 47 mono, 2 for stereo) 48 getsampwidth() -- returns sample width in bytes 49 getframerate() -- returns sampling frequency 50 getnframes() -- returns number of audio frames 51 getcomptype() -- returns compression type ('NONE' or 'ULAW') 52 getcompname() -- returns human-readable version of 53 compression type ('not compressed' matches 'NONE') 54 getparams() -- returns a tuple consisting of all of the 55 above in the above order 56 getmarkers() -- returns None (for compatibility with the 57 aifc module) 58 getmark(id) -- raises an error since the mark does not 59 exist (for compatibility with the aifc module) 60 readframes(n) -- returns at most n frames of audio 61 rewind() -- rewind to the beginning of the audio stream 62 setpos(pos) -- seek to the specified position 63 tell() -- return the current position 64 close() -- close the instance (make it unusable) 65 The position returned by tell() and the position given to setpos() 66 are compatible and have nothing to do with the actual position in the 67 file. 68 The close() method is called automatically when the class instance 69 is destroyed. 70 71 Writing audio files: 72 f = sunau.open(file, 'w') 73 where file is either the name of a file or an open file pointer. 74 The open file pointer must have methods write(), tell(), seek(), and 75 close(). 76 77 This returns an instance of a class with the following public methods: 78 setnchannels(n) -- set the number of channels 79 setsampwidth(n) -- set the sample width 80 setframerate(n) -- set the frame rate 81 setnframes(n) -- set the number of frames 82 setcomptype(type, name) 83 -- set the compression type and the 84 human-readable compression type 85 setparams(tuple)-- set all parameters at once 86 tell() -- return current position in output file 87 writeframesraw(data) 88 -- write audio frames without pathing up the 89 file header 90 writeframes(data) 91 -- write audio frames and patch up the file header 92 close() -- patch up the file header and close the 93 output file 94 You should set the parameters before the first writeframesraw or 95 writeframes. The total number of frames does not need to be set, 96 but when it is set to the correct value, the header does not have to 97 be patched up. 98 It is best to first set all parameters, perhaps possibly the 99 compression type, and then write audio frames using writeframesraw. 100 When all frames have been written, either call writeframes('') or 101 close() to patch up the sizes in the header. 102 The close() method is called automatically when the class instance 103 is destroyed. 104 """ 105 106 # from <multimedia/audio_filehdr.h> 107 AUDIO_FILE_MAGIC = 0x2e736e64 108 AUDIO_FILE_ENCODING_MULAW_8 = 1 109 AUDIO_FILE_ENCODING_LINEAR_8 = 2 110 AUDIO_FILE_ENCODING_LINEAR_16 = 3 111 AUDIO_FILE_ENCODING_LINEAR_24 = 4 112 AUDIO_FILE_ENCODING_LINEAR_32 = 5 113 AUDIO_FILE_ENCODING_FLOAT = 6 114 AUDIO_FILE_ENCODING_DOUBLE = 7 115 AUDIO_FILE_ENCODING_ADPCM_G721 = 23 116 AUDIO_FILE_ENCODING_ADPCM_G722 = 24 117 AUDIO_FILE_ENCODING_ADPCM_G723_3 = 25 118 AUDIO_FILE_ENCODING_ADPCM_G723_5 = 26 119 AUDIO_FILE_ENCODING_ALAW_8 = 27 120 121 # from <multimedia/audio_hdr.h> 122 AUDIO_UNKNOWN_SIZE = 0xFFFFFFFFL # ((unsigned)(~0)) 123 124 _simple_encodings = [AUDIO_FILE_ENCODING_MULAW_8, 125 AUDIO_FILE_ENCODING_LINEAR_8, 126 AUDIO_FILE_ENCODING_LINEAR_16, 127 AUDIO_FILE_ENCODING_LINEAR_24, 128 AUDIO_FILE_ENCODING_LINEAR_32, 129 AUDIO_FILE_ENCODING_ALAW_8] 130 131 class Error(Exception): 132 pass 133 134 def _read_u32(file): 135 x = 0L 136 for i in range(4): 137 byte = file.read(1) 138 if byte == '': 139 raise EOFError 140 x = x*256 + ord(byte) 141 return x 142 143 def _write_u32(file, x): 144 data = [] 145 for i in range(4): 146 d, m = divmod(x, 256) 147 data.insert(0, m) 148 x = d 149 for i in range(4): 150 file.write(chr(int(data[i]))) 151 152 class Au_read: 153 154 def __init__(self, f): 155 if type(f) == type(''): 156 import __builtin__ 157 f = __builtin__.open(f, 'rb') 158 self.initfp(f) 159 160 def __del__(self): 161 if self._file: 162 self.close() 163 164 def initfp(self, file): 165 self._file = file 166 self._soundpos = 0 167 magic = int(_read_u32(file)) 168 if magic != AUDIO_FILE_MAGIC: 169 raise Error, 'bad magic number' 170 self._hdr_size = int(_read_u32(file)) 171 if self._hdr_size < 24: 172 raise Error, 'header size too small' 173 if self._hdr_size > 100: 174 raise Error, 'header size ridiculously large' 175 self._data_size = _read_u32(file) 176 if self._data_size != AUDIO_UNKNOWN_SIZE: 177 self._data_size = int(self._data_size) 178 self._encoding = int(_read_u32(file)) 179 if self._encoding not in _simple_encodings: 180 raise Error, 'encoding not (yet) supported' 181 if self._encoding in (AUDIO_FILE_ENCODING_MULAW_8, 182 AUDIO_FILE_ENCODING_ALAW_8): 183 self._sampwidth = 2 184 self._framesize = 1 185 elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_8: 186 self._framesize = self._sampwidth = 1 187 elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_16: 188 self._framesize = self._sampwidth = 2 189 elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_24: 190 self._framesize = self._sampwidth = 3 191 elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_32: 192 self._framesize = self._sampwidth = 4 193 else: 194 raise Error, 'unknown encoding' 195 self._framerate = int(_read_u32(file)) 196 self._nchannels = int(_read_u32(file)) 197 self._framesize = self._framesize * self._nchannels 198 if self._hdr_size > 24: 199 self._info = file.read(self._hdr_size - 24) 200 for i in range(len(self._info)): 201 if self._info[i] == '\0': 202 self._info = self._info[:i] 203 break 204 else: 205 self._info = '' 206 207 def getfp(self): 208 return self._file 209 210 def getnchannels(self): 211 return self._nchannels 212 213 def getsampwidth(self): 214 return self._sampwidth 215 216 def getframerate(self): 217 return self._framerate 218 219 def getnframes(self): 220 if self._data_size == AUDIO_UNKNOWN_SIZE: 221 return AUDIO_UNKNOWN_SIZE 222 if self._encoding in _simple_encodings: 223 return self._data_size / self._framesize 224 return 0 # XXX--must do some arithmetic here 225 226 def getcomptype(self): 227 if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: 228 return 'ULAW' 229 elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8: 230 return 'ALAW' 231 else: 232 return 'NONE' 233 234 def getcompname(self): 235 if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: 236 return 'CCITT G.711 u-law' 237 elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8: 238 return 'CCITT G.711 A-law' 239 else: 240 return 'not compressed' 241 242 def getparams(self): 243 return self.getnchannels(), self.getsampwidth(), \ 244 self.getframerate(), self.getnframes(), \ 245 self.getcomptype(), self.getcompname() 246 247 def getmarkers(self): 248 return None 249 250 def getmark(self, id): 251 raise Error, 'no marks' 252 253 def readframes(self, nframes): 254 if self._encoding in _simple_encodings: 255 if nframes == AUDIO_UNKNOWN_SIZE: 256 data = self._file.read() 257 else: 258 data = self._file.read(nframes * self._framesize * self._nchannels) 259 if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: 260 import audioop 261 data = audioop.ulaw2lin(data, self._sampwidth) 262 return data 263 return None # XXX--not implemented yet 264 265 def rewind(self): 266 self._soundpos = 0 267 self._file.seek(self._hdr_size) 268 269 def tell(self): 270 return self._soundpos 271 272 def setpos(self, pos): 273 if pos < 0 or pos > self.getnframes(): 274 raise Error, 'position not in range' 275 self._file.seek(pos * self._framesize + self._hdr_size) 276 self._soundpos = pos 277 278 def close(self): 279 self._file = None 280 281 class Au_write: 282 283 def __init__(self, f): 284 if type(f) == type(''): 285 import __builtin__ 286 f = __builtin__.open(f, 'wb') 287 self.initfp(f) 288 289 def __del__(self): 290 if self._file: 291 self.close() 292 293 def initfp(self, file): 294 self._file = file 295 self._framerate = 0 296 self._nchannels = 0 297 self._sampwidth = 0 298 self._framesize = 0 299 self._nframes = AUDIO_UNKNOWN_SIZE 300 self._nframeswritten = 0 301 self._datawritten = 0 302 self._datalength = 0 303 self._info = '' 304 self._comptype = 'ULAW' # default is U-law 305 306 def setnchannels(self, nchannels): 307 if self._nframeswritten: 308 raise Error, 'cannot change parameters after starting to write' 309 if nchannels not in (1, 2, 4): 310 raise Error, 'only 1, 2, or 4 channels supported' 311 self._nchannels = nchannels 312 313 def getnchannels(self): 314 if not self._nchannels: 315 raise Error, 'number of channels not set' 316 return self._nchannels 317 318 def setsampwidth(self, sampwidth): 319 if self._nframeswritten: 320 raise Error, 'cannot change parameters after starting to write' 321 if sampwidth not in (1, 2, 4): 322 raise Error, 'bad sample width' 323 self._sampwidth = sampwidth 324 325 def getsampwidth(self): 326 if not self._framerate: 327 raise Error, 'sample width not specified' 328 return self._sampwidth 329 330 def setframerate(self, framerate): 331 if self._nframeswritten: 332 raise Error, 'cannot change parameters after starting to write' 333 self._framerate = framerate 334 335 def getframerate(self): 336 if not self._framerate: 337 raise Error, 'frame rate not set' 338 return self._framerate 339 340 def setnframes(self, nframes): 341 if self._nframeswritten: 342 raise Error, 'cannot change parameters after starting to write' 343 if nframes < 0: 344 raise Error, '# of frames cannot be negative' 345 self._nframes = nframes 346 347 def getnframes(self): 348 return self._nframeswritten 349 350 def setcomptype(self, type, name): 351 if type in ('NONE', 'ULAW'): 352 self._comptype = type 353 else: 354 raise Error, 'unknown compression type' 355 356 def getcomptype(self): 357 return self._comptype 358 359 def getcompname(self): 360 if self._comptype == 'ULAW': 361 return 'CCITT G.711 u-law' 362 elif self._comptype == 'ALAW': 363 return 'CCITT G.711 A-law' 364 else: 365 return 'not compressed' 366 367 def setparams(self, params): 368 nchannels, sampwidth, framerate, nframes, comptype, compname = params 369 self.setnchannels(nchannels) 370 self.setsampwidth(sampwidth) 371 self.setframerate(framerate) 372 self.setnframes(nframes) 373 self.setcomptype(comptype, compname) 374 375 def getparams(self): 376 return self.getnchannels(), self.getsampwidth(), \ 377 self.getframerate(), self.getnframes(), \ 378 self.getcomptype(), self.getcompname() 379 380 def tell(self): 381 return self._nframeswritten 382 383 def writeframesraw(self, data): 384 self._ensure_header_written() 385 nframes = len(data) / self._framesize 386 if self._comptype == 'ULAW': 387 import audioop 388 data = audioop.lin2ulaw(data, self._sampwidth) 389 self._file.write(data) 390 self._nframeswritten = self._nframeswritten + nframes 391 self._datawritten = self._datawritten + len(data) 392 393 def writeframes(self, data): 394 self.writeframesraw(data) 395 if self._nframeswritten != self._nframes or \ 396 self._datalength != self._datawritten: 397 self._patchheader() 398 399 def close(self): 400 self._ensure_header_written() 401 if self._nframeswritten != self._nframes or \ 402 self._datalength != self._datawritten: 403 self._patchheader() 404 self._file.flush() 405 self._file = None 406 407 # 408 # private methods 409 # 410 411 def _ensure_header_written(self): 412 if not self._nframeswritten: 413 if not self._nchannels: 414 raise Error, '# of channels not specified' 415 if not self._sampwidth: 416 raise Error, 'sample width not specified' 417 if not self._framerate: 418 raise Error, 'frame rate not specified' 419 self._write_header() 420 421 def _write_header(self): 422 if self._comptype == 'NONE': 423 if self._sampwidth == 1: 424 encoding = AUDIO_FILE_ENCODING_LINEAR_8 425 self._framesize = 1 426 elif self._sampwidth == 2: 427 encoding = AUDIO_FILE_ENCODING_LINEAR_16 428 self._framesize = 2 429 elif self._sampwidth == 4: 430 encoding = AUDIO_FILE_ENCODING_LINEAR_32 431 self._framesize = 4 432 else: 433 raise Error, 'internal error' 434 elif self._comptype == 'ULAW': 435 encoding = AUDIO_FILE_ENCODING_MULAW_8 436 self._framesize = 1 437 else: 438 raise Error, 'internal error' 439 self._framesize = self._framesize * self._nchannels 440 _write_u32(self._file, AUDIO_FILE_MAGIC) 441 header_size = 25 + len(self._info) 442 header_size = (header_size + 7) & ~7 443 _write_u32(self._file, header_size) 444 if self._nframes == AUDIO_UNKNOWN_SIZE: 445 length = AUDIO_UNKNOWN_SIZE 446 else: 447 length = self._nframes * self._framesize 448 _write_u32(self._file, length) 449 self._datalength = length 450 _write_u32(self._file, encoding) 451 _write_u32(self._file, self._framerate) 452 _write_u32(self._file, self._nchannels) 453 self._file.write(self._info) 454 self._file.write('\0'*(header_size - len(self._info) - 24)) 455 456 def _patchheader(self): 457 self._file.seek(8) 458 _write_u32(self._file, self._datawritten) 459 self._datalength = self._datawritten 460 self._file.seek(0, 2) 461 462 def open(f, mode=None): 463 if mode is None: 464 if hasattr(f, 'mode'): 465 mode = f.mode 466 else: 467 mode = 'rb' 468 if mode in ('r', 'rb'): 469 return Au_read(f) 470 elif mode in ('w', 'wb'): 471 return Au_write(f) 472 else: 473 raise Error, "mode must be 'r', 'rb', 'w', or 'wb'" 474 475 openfp = open 476
