def test_read_no_ssnd_chunk(self): b = b'FORM' + struct.pack('>L', 4) + b'AIFC' b += b'COMM' + struct.pack('>LhlhhLL', 38, 0, 0, 0, 0, 0, 0) b += b'NONE' + struct.pack('B', 14) + b'not compressed' + b'\x00' with self.assertRaisesRegex(aifc.Error, 'COMM chunk and/or SSND chunk' ' missing'): aifc.open(io.BytesIO(b))
def test_read_wrong_number_of_channels(self): for nchannels in 0, -1: b = b'FORM' + struct.pack('>L', 4) + b'AIFC' b += b'COMM' + struct.pack('>LhlhhLL', 38, nchannels, 0, 8, 0x4000 | 12, 11025<<18, 0) b += b'NONE' + struct.pack('B', 14) + b'not compressed' + b'\x00' b += b'SSND' + struct.pack('>L', 8) + b'\x00' * 8 with self.assertRaisesRegex(aifc.Error, 'bad # of channels'): aifc.open(io.BytesIO(b))
def test_read_wrong_sample_width(self): for sampwidth in 0, -1: b = b'FORM' + struct.pack('>L', 4) + b'AIFC' b += b'COMM' + struct.pack('>LhlhhLL', 38, 1, 0, sampwidth, 0x4000 | 12, 11025<<18, 0) b += b'NONE' + struct.pack('B', 14) + b'not compressed' + b'\x00' b += b'SSND' + struct.pack('>L', 8) + b'\x00' * 8 with self.assertRaisesRegex(aifc.Error, 'bad sample width'): aifc.open(io.BytesIO(b))
def test_write_header_raises(self): fout = aifc.open(io.BytesIO(), 'wb') self.assertRaises(aifc.Error, fout.close) fout = aifc.open(io.BytesIO(), 'wb') fout.setnchannels(1) self.assertRaises(aifc.Error, fout.close) fout = aifc.open(io.BytesIO(), 'wb') fout.setnchannels(1) fout.setsampwidth(1) self.assertRaises(aifc.Error, fout.close)
def test_write_aiff_by_extension(self): sampwidth = 2 fout = self.fout = aifc.open(TESTFN + '.aiff', 'wb') fout.setparams((1, sampwidth, 1, 1, b'ULAW', b'')) frames = b'\x00' * fout.getnchannels() * sampwidth fout.writeframes(frames) fout.close() f = self.f = aifc.open(TESTFN + '.aiff', 'rb') self.assertEqual(f.getcomptype(), b'NONE') f.close()
def test_context_manager(self): with open(self.sndfilepath, 'rb') as testfile: with aifc.open(testfile) as f: pass self.assertEqual(testfile.closed, True) with open(TESTFN, 'wb') as testfile: with self.assertRaises(aifc.Error): with aifc.open(testfile, 'wb') as fout: pass self.assertEqual(testfile.closed, True) fout.close() # do nothing
def generate_samples(sample_folder, file_path, num_samples): output('Genearating samples for: {}'.format(file_path)) f = aifc.open(file_path, "r") num_channels = f.getnchannels() sample_width = f.getsampwidth() frame_rate = f.getframerate() # Frame size = nchannels*samplesize bytes frame_size = num_channels * sample_width # One second of audio = nchannels*samplesize*framerate bytes bytes_per_second = frame_size * frame_rate data = f.readframes(f.getnframes()) seconds = len(data) / bytes_per_second # 1/4 second min_sample_length = bytes_per_second / 4 # 2 second max_sample_length = bytes_per_second * 2 sample_number = 0 while sample_number < num_samples: sample_name = uuid.uuid4() output('Generating sample: {} {}/{}'.format(sample_name, sample_number, num_samples), color='blue') sample_file = aifc.open('{}/{}.aif'.format(sample_folder, sample_name), 'w') sample_file.aiff() sample_file.setnchannels(num_channels) sample_file.setsampwidth(sample_width) sample_file.setframerate(frame_rate) sample_file.setcomptype('NONE', 'no compression') sample_file.setparams(sample_file.getparams()) sample_length = random.randint(min_sample_length, max_sample_length) second_offset = random.randint(0, seconds - (max_sample_length / bytes_per_second)) start_byte_index = second_offset * bytes_per_second end_byte_index = start_byte_index + sample_length sample_file.writeframesraw(data[start_byte_index:end_byte_index]) sample_file.close() sample_number += 1 f.close()
def test_write(self): f = self.f = aifc.open(self.sndfilepath) fout = self.fout = aifc.open(TESTFN, 'wb') fout.aifc() fout.setparams(f.getparams()) for frame in range(f.getnframes()): fout.writeframes(f.readframes(1)) fout.close() fout = self.fout = aifc.open(TESTFN, 'rb') f.rewind() self.assertEqual(f.getparams(), fout.getparams()) self.assertEqual(f.readframes(5), fout.readframes(5))
def test_read_markers(self): fout = self.fout = aifc.open(TESTFN, 'wb') fout.aiff() fout.setparams((1, 1, 1, 1, b'NONE', b'')) fout.setmark(1, 0, b'odd') fout.setmark(2, 0, b'even') fout.writeframes(b'\x00') fout.close() f = self.f = aifc.open(TESTFN, 'rb') self.assertEqual(f.getmarkers(), [(1, 0, b'odd'), (2, 0, b'even')]) self.assertEqual(f.getmark(1), (1, 0, b'odd')) self.assertEqual(f.getmark(2), (2, 0, b'even')) self.assertRaises(aifc.Error, f.getmark, 3)
def __enter__(self): assert self.stream is None, "This audio source is already inside a context manager" try: # attempt to read the file as WAV self.audio_reader = wave.open(self.filename_or_fileobject, "rb") self.little_endian = True # RIFF WAV is a little-endian format (most ``audioop`` operations assume frames are stored in little-endian form) except wave.Error: try: # attempt to read the file as AIFF self.audio_reader = aifc.open(self.filename_or_fileobject, "rb") self.little_endian = False # AIFF is a big-endian format except aifc.Error: # attempt to read the file as FLAC if hasattr(self.filename_or_fileobject, "read"): flac_data = self.filename_or_fileobject.read() else: with open(self.filename_or_fileobject, "rb") as f: flac_data = f.read() # run the FLAC converter with the FLAC data to get the AIFF data flac_converter = get_flac_converter() process = subprocess.Popen([ flac_converter, "--stdout", "--totally-silent", # put the resulting AIFF file in stdout, and make sure it's not mixed with any program output "--decode", "--force-aiff-format", # decode the FLAC file into an AIFF file "-", # the input FLAC file contents will be given in stdin ], stdin=subprocess.PIPE, stdout=subprocess.PIPE) aiff_data, stderr = process.communicate(flac_data) aiff_file = io.BytesIO(aiff_data) try: self.audio_reader = aifc.open(aiff_file, "rb") except aifc.Error: assert False, "Audio file could not be read as WAV, AIFF, or FLAC; check if file is corrupted" self.little_endian = False # AIFF is a big-endian format assert 1 <= self.audio_reader.getnchannels() <= 2, "Audio must be mono or stereo" self.SAMPLE_WIDTH = self.audio_reader.getsampwidth() # 24-bit audio needs some special handling for old Python versions (workaround for https://bugs.python.org/issue12866) samples_24_bit_pretending_to_be_32_bit = False if self.SAMPLE_WIDTH == 3: # 24-bit audio try: audioop.bias(b"", self.SAMPLE_WIDTH, 0) # test whether this sample width is supported (for example, ``audioop`` in Python 3.3 and below don't support sample width 3, while Python 3.4+ do) except audioop.error: # this version of audioop doesn't support 24-bit audio (probably Python 3.3 or less) samples_24_bit_pretending_to_be_32_bit = True # while the ``AudioFile`` instance will outwardly appear to be 32-bit, it will actually internally be 24-bit self.SAMPLE_WIDTH = 4 # the ``AudioFile`` instance should present itself as a 32-bit stream now, since we'll be converting into 32-bit on the fly when reading self.SAMPLE_RATE = self.audio_reader.getframerate() self.CHUNK = 4096 self.FRAME_COUNT = self.audio_reader.getnframes() self.DURATION = self.FRAME_COUNT / float(self.SAMPLE_RATE) self.stream = AudioFile.AudioFileStream(self.audio_reader, self.little_endian, samples_24_bit_pretending_to_be_32_bit) return self
def main(): #raw = aifc.open("/Users/katiemalone/Desktop/data_podcast/fisherfaces/fisherfaces.aif", "r") #edited = aifc.open("/Users/katiemalone/Desktop/data_podcast/fisherfaces/fisherfaces_edited.aif", "r") raw = aifc.open("fisherfaces.aif", "r") edited = aifc.open("fisherfaces_edited.aif", "r") print raw.getparams() s_markers, b_markers = preprocess.signalBackgroundMarkers( raw ) window_length = preprocess.findMaxWindow(s_markers) s_frames = preprocess.normedFrames( raw, window_length, start_points=s_markers) # drawFrames( s_frames ) b_frames = preprocess.normedFrames( edited, window_length, n_samples=200 ) # drawFrames( b_frames ) features = [] labels = [] for ii in range(0, len(s_frames)): features.append(s_frames[ii]) labels.append(1) for jj in range(0, len(b_frames)): features.append(b_frames[jj]) labels.append(0) print "data acquisition done" features = np.asarray( features ) labels = np.asarray( labels ) features, labels = transform( features, labels ) # f, axarr = plt.subplots(2, 2) # ctr = 0 for ff, ll in zip(features, labels): if ll==0: #axarr[0, 0].scatter( ff[0], ff[1], color="red") plt.scatter( ff[0], ff[1], color="red") if ll==1: plt.scatter( ff[0], ff[1], color="blue") # for ii in range(0,n): # for jj in range(0,n): # axarr[ii, jj].plot( frames[ctr] ) # ctr += 1 plt.show() classify( features, labels )
def test_params_added(self): f = self.f = aifc.open(TESTFN, 'wb') f.aiff() f.setparams((1, 1, 1, 1, b'NONE', b'')) f.close() f = self.f = aifc.open(TESTFN, 'rb') params = f.getparams() self.assertEqual(params.nchannels, f.getnchannels()) self.assertEqual(params.sampwidth, f.getsampwidth()) self.assertEqual(params.framerate, f.getframerate()) self.assertEqual(params.nframes, f.getnframes()) self.assertEqual(params.comptype, f.getcomptype()) self.assertEqual(params.compname, f.getcompname())
def test_close_opened_files_on_error(self): non_aifc_file = findfile('pluck-pcm8.wav', subdir='audiodata') with check_no_resource_warning(self): with self.assertRaises(aifc.Error): # Try opening a non-AIFC file, with the expectation that # `aifc.open` will fail (without raising a ResourceWarning) self.f = aifc.open(non_aifc_file, 'rb') # Aifc_write.initfp() won't raise in normal case. But some errors # (e.g. MemoryError, KeyboardInterrupt, etc..) can happen. with mock.patch.object(aifc.Aifc_write, 'initfp', side_effect=RuntimeError): with self.assertRaises(RuntimeError): self.fout = aifc.open(TESTFN, 'wb')
def test_write_aiff_by_extension(self): sampwidth = 2 filename = TESTFN + '.aiff' self.addCleanup(unlink, filename) fout = self.fout = aifc.open(filename, 'wb') fout.setparams((1, sampwidth, 1, 1, 'ULAW', '')) frames = '\x00' * fout.getnchannels() * sampwidth fout.writeframes(frames) fout.close() f = self.f = aifc.open(filename, 'rb') self.assertEqual(f.getcomptype(), 'NONE') f.close()
def aiffread(filename): af = aifc.open(filename, "r") fs = af.getframerate() x = af.readframes(af.getnframes()) x = np.frombuffer(x, dtype="int16") / 32768.0 # (-1, 1)に正規化 af.close() return x, float(fs)
def specgram_large: nfft=256; nt=20; fs=2000; dt=1./fs; fmax=400; nframes = 4000 # Read Data print filename f = aifc.open(filename, "r") strsig = f.readframes(nframes) f.close() x = numpy.fromstring(strsig, numpy.short).byteswap() n = len(x) # Initialize output nf=nfft/2.+1 tt = numpy.arange(dt*(nfft-1)/2, (n-1)*dt-(nfft/2)*dt, nt * dt) ntt=len(tt) y = numpy.zeros(nf * ntt).reshape(nf, ntt); # Create Window vector xw = range(0, nfft) wind = map(lambda a: 0.5 * (1 - math.cos((a * 2 * math.pi) / (nfft - 1.0))), xw) for i in range(0, ntt): zi = numpy.arange(i*nt, nfft*(i+1) - i*(nfft-nt)) xss = scipy.fft(x[zi] * wind, nfft)/nfft yy = 2 * abs(xss[0:(nfft/2)+1]) y[:, i] = yy # Return y return y.reshape(nf * ntt)
def __init__(self, path, speed=1, mark=0, interp=2, mul=1, add=0): pyoArgsAssert(self, "sOOiOO", path, speed, mark, interp, mul, add) PyoObject.__init__(self, mul, add) self._speed = speed self._mark = mark self._interp = interp path, speed, mark, interp, mul, add, lmax = convertArgsToLists(path, speed, mark, interp, mul, add) self._base_players = [] self._base_objs = [] self._snd_size, self._dur, self._snd_sr, self._snd_chnls, _format, _type = sndinfo(path[0]) for i in range(lmax): try: sf = aifc.open(wrap(path, i)) markerstmp = sf.getmarkers() sf.close() self._markers = [m[1] for m in markerstmp] except: self._markers = [] self._base_players.append( SfMarkerLooper_base(wrap(path, i), self._markers, wrap(speed, i), wrap(mark, i), wrap(interp, i)) ) for i in range(lmax * self._snd_chnls): j = i // self._snd_chnls self._base_objs.append( SfMarkerLoop_base(wrap(self._base_players, j), i % self._snd_chnls, wrap(mul, j), wrap(add, j)) )
def test_write_params_bunch(self): fout = aifc.open(io.BytesIO(), 'wb') fout.aifc() p = (1, 2, 3, 4, b'NONE', b'name') fout.setparams(p) self.assertEqual(fout.getparams(), p) fout.initfp(None)
def __init__(self, filename): self._fh = open(filename, 'rb') try: self._file = aifc.open(self._fh) except aifc.Error: # Return to the beginning of the file to try the WAV reader. self._fh.seek(0) else: self._needs_byteswap = True return try: self._file = wave.open(self._fh) except wave.Error: # Return to the beginning of the file to try the next reader self._fh.seek(0) pass else: self._needs_byteswap = False return try: self._file = sunau.open(self._fh) except sunau.Error: # Return to the beginning of the file to try the next reader self._fh.seek(0) pass else: self._needs_byteswap = True return raise UnsupportedError()
def read_samples(dir): allSigs = np.zeros( (len(os.listdir(dir)),SAMPLE_LENGTH*SAMPLE_RATE) ) filenames = [] targets = [] for cnt, filename in enumerate(os.listdir(dir)): if os.path.isfile(os.path.join(dir, filename)): filenames.append(filename) if dir == traindir: targets.append(int(re.search('(ms_TRAIN[0-9]*\_([0-9]*))',filename).group(2))) else: targets.append(0) sample = aifc.open(os.path.join(dir, filename), 'r') nframes = sample.getnframes() strSig = sample.readframes(nframes) sig = np.fromstring(strSig, np.short).byteswap() if nframes > 4000: sig = sig[nframes-4000//2:(nframes-4000//2)+4000] elif nframes < 4000: # appending is OK instead of symmetrical prepending and appending, # since we're going to sample patches anyway sig = np.append(sig,np.zeros(4000-nframes)) allSigs[cnt,:] = sig sample.close() targets = np.array(targets) return filenames, targets, allSigs
def test_write_header_comptype_raises(self): for comptype in (b'ULAW', b'ulaw', b'ALAW', b'alaw', b'G722'): fout = aifc.open(io.BytesIO(), 'wb') fout.setsampwidth(1) fout.setcomptype(comptype, b'') self.assertRaises(aifc.Error, fout.close) fout.initfp(None)
def test_write_markers_raises(self): fout = aifc.open(io.BytesIO(), 'wb') self.assertRaises(aifc.Error, fout.setmark, 0, 0, b'') self.assertRaises(aifc.Error, fout.setmark, 1, -1, b'') self.assertRaises(aifc.Error, fout.setmark, 1, 0, None) self.assertRaises(aifc.Error, fout.getmark, 1) fout.initfp(None)
def test_write_params_raises(self): fout = aifc.open(io.BytesIO(), 'wb') wrong_params = (0, 0, 0, 0, b'WRNG', '') self.assertRaises(aifc.Error, fout.setparams, wrong_params) self.assertRaises(aifc.Error, fout.getparams) self.assertRaises(aifc.Error, fout.setnchannels, 0) self.assertRaises(aifc.Error, fout.getnchannels) self.assertRaises(aifc.Error, fout.setsampwidth, 0) self.assertRaises(aifc.Error, fout.getsampwidth) self.assertRaises(aifc.Error, fout.setframerate, 0) self.assertRaises(aifc.Error, fout.getframerate) self.assertRaises(aifc.Error, fout.setcomptype, b'WRNG', '') fout.aiff() fout.setnchannels(1) fout.setsampwidth(1) fout.setframerate(1) fout.setnframes(1) fout.writeframes(b'\x00') self.assertRaises(aifc.Error, fout.setparams, (1, 1, 1, 1, 1, 1)) self.assertRaises(aifc.Error, fout.setnchannels, 1) self.assertRaises(aifc.Error, fout.setsampwidth, 1) self.assertRaises(aifc.Error, fout.setframerate, 1) self.assertRaises(aifc.Error, fout.setnframes, 1) self.assertRaises(aifc.Error, fout.setcomptype, b'NONE', '') self.assertRaises(aifc.Error, fout.aiff) self.assertRaises(aifc.Error, fout.aifc)
def get_soundfile(filename,dplot = 1): """ reads in the acii file, optionally plots """ #open file wf = aifc.open(filename, 'rb') #read data data = wf.readframes(wf.getnframes()) srate = wf.getframerate() #close file wf.close() #format data, time data_int = pylab.fromstring(data,dtype=np.int32) n = data_int.size time = np.arange(n)/float(srate) time = time*1000 #ms #plot sound file if dplot: fig = plt.figure() ax1 = fig.add_subplot(1,1,1) ax1.plot(time,data_int) ax1.set_xlim(min(time), max(time)) ax1.set_xlabel("Time [ms]") ax1.set_ylabel("Amplitude") return data_int, srate
def main(): f = CurrentFont() a = aifc.open("aiff_out/aiffSlice.aiff", "wb") a.setnchannels(1) a.setsampwidth(4) a.setframerate(44100) #for i in range(80): # v = sin(i/44100.0 * 440.0 * pi) * 2**7 # print v # a.writeframes(pack("h", v)) for n in f.selection: g = f[n] print n #for c in g.contours: # print c.box # for for i in range(int(g.width)): pen = MarginPen(f, i, isHorizontal=False) g.draw(pen) l = pen.getAll() #print l, v = getAverage(l) #print v a.writeframes(pack("i", v)) a.writeframes(pack("i", v)) a.close()
def compute_specgram(data_loc,train_folder,file_name): '''Retrieves time data from the aiff file and compute the spectogram for time_data''' if not os.path.isfile(data_loc + '/' + train_folder + '/specgrams/' + file_name.split('.')[0] + '.png'): try: plt.figure(figsize=(18.,16.), dpi=50) #900x800 f = aifc.open(os.path.join(data_loc,train_folder, file_name), 'r') str_frames = f.readframes(f.getnframes()) #Fs = f.getframerate() Fs= 4000 time_data = np.fromstring(str_frames, np.short).byteswap() f.close() # Pxx is the segments x freqs array of instantaneous power, freqs is # the frequency vector, bins are the centers of the time bins in which # the power is computed, and im is the matplotlib.image.AxesImage # instance # spectrogram of file Pxx, freqs, bins, im = plt.specgram(time_data,Fs=Fs,noverlap=90,cmap=plt.cm.gist_heat) plt.axis('off') plt.savefig(data_loc + '/'+ train_folder + '/specgrams/'+ file_name.split('.')[0] + '.png', bbox_inches='tight') plt.close() except ValueError: print("Error in file: "+ file_name + "...\n")
def get_aiff_data(self, convert_rate = None, convert_width = None): """ Returns a byte string representing the contents of an AIFF-C file containing the audio represented by the ``AudioData`` instance. If ``convert_width`` is specified and the audio samples are not ``convert_width`` bytes each, the resulting audio is converted to match. If ``convert_rate`` is specified and the audio sample rate is not ``convert_rate`` Hz, the resulting audio is resampled to match. Writing these bytes directly to a file results in a valid `AIFF-C file <https://en.wikipedia.org/wiki/Audio_Interchange_File_Format>`__. """ raw_data = self.get_raw_data(convert_rate, convert_width) sample_rate = self.sample_rate if convert_rate is None else convert_rate sample_width = self.sample_width if convert_width is None else convert_width # the AIFF format is big-endian, so we need to covnert the little-endian raw data to big-endian if hasattr(audioop, "byteswap"): # ``audioop.byteswap`` was only added in Python 3.4 raw_data = audioop.byteswap(raw_data, sample_width) else: # manually reverse the bytes of each sample, which is slower but works well enough as a fallback raw_data = raw_data[sample_width - 1::-1] + b"".join(raw_data[i + sample_width:i:-1] for i in range(sample_width - 1, len(raw_data), sample_width)) # generate the AIFF-C file contents with io.BytesIO() as aiff_file: aiff_writer = aifc.open(aiff_file, "wb") try: # note that we can't use context manager, since that was only added in Python 3.4 aiff_writer.setframerate(sample_rate) aiff_writer.setsampwidth(sample_width) aiff_writer.setnchannels(1) aiff_writer.writeframes(raw_data) aiff_data = aiff_file.getvalue() finally: # make sure resources are cleaned up aiff_writer.close() return aiff_data
def process_image(file_name, enlarge = True, image_height = 129, image_width = 23): '''Retrieves time data from the aiff file and compute the spectogram for time_data''' '''enlarge: gives option to resize the image to new dimensions WxH by interpolation''' if file_name.endswith('.aiff'): f = aifc.open(file_name, 'r') str_frames = f.readframes(f.getnframes()) Fs = f.getframerate() time_data = np.fromstring(str_frames, np.short).byteswap() f.close() Pxx, freqs, bins, im = plt.specgram(time_data,NFFT=256,Fs=Fs,noverlap=90,cmap=plt.cm.gist_heat) Pxx = Pxx[[freqs<250.]] # Right-whales call occur under 250Hz #print Pxx.shape from scipy.misc import imresize from sklearn import preprocessing if enlarge: #change image size Pxx_prep = imresize(np.log10(Pxx),(image_height,image_width), interp= 'lanczos').astype('float32') #Pxx_prep = imresize(Pxx,(image_height,image_width), interp= 'lanczos').astype('float32') else: #image size not changed Pxx_prep = np.log(Pxx).astype('float32') #Pxx_prep = preprocessing.MinMaxScaler().fit_transform(Pxx_prep) #rescale to 0-1 Pxx_prep = preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True).fit_transform(Pxx_prep) #rescale by std Pxx_ = (Pxx_prep*255.0).astype(int) # Returning raw values to perform operations. Used to obtain raw data for ipynb #Pxx_ = Pxx_prep #Pxx_ = Pxx return Pxx_ else: print("Error in file: "+ file_name + "...\n") pass
def open(file_name): name = os.path.abspath(file_name) if not os.path.exists(file_name): raise IOError("No such file or directory: '%s'" % file_name) _, file_ext = os.path.splitext(name) file_ext = file_ext[1:] proc_args = [] audio_file = None if file_ext in ("mp4", "m4a", "m4b", "aac"): proc_args = [FAAD_BIN, "-q", "-f", "2", "-w", name] elif file_ext == "ogg": proc_args = [OGG_BIN, "-q", "-o", "-", name] elif file_ext in ("wav", "wave"): audio_file = wave.open(name, "r") elif file_ext in ("aiff", "aif"): audio_file = aifc.open(name, "r") elif file_ext in ("mp1", "mp2", "mp3"): proc_args = [LAME_BIN, "--quiet", "--decode", name, "-"] elif file_ext in ("flac", "oga"): proc_args = [FLAC_BIN, "--silent", "--stdout", "-d", name] elif file_ext == "wma": proc_args = [FFMPEG_BIN, "-i", name, "-f", "wav", "-"] if proc_args: proc = subprocess.Popen(proc_args, stdout=subprocess.PIPE) audio_file = PCMProxy(proc, name) return audio_file
def load_aiff(filename): snd = aifc.open(filename) snd_string = snd.readframes(snd.getnframes()) snd.close() # need to do .byteswap as aifc loads / converts to a bytestring in # MSB ordering, but numpy assumes LSB ordering. return np.fromstring(snd_string, dtype=np.uint16).byteswap()
def test_close(self): class Wrapfile(object): def __init__(self, file): self.file = open(file, 'rb') self.closed = False def close(self): self.file.close() self.closed = True def __getattr__(self, attr): return getattr(self.file, attr) testfile = Wrapfile(self.sndfilepath) f = self.f = aifc.open(testfile) self.assertEqual(testfile.closed, False) f.close() self.assertEqual(testfile.closed, True)
def verify_aiff(aiffPath): if not os.path.exists(aiffPath): print("Error: aiff file does not exist.") return False try: a = aifc.open(aiffPath, "r") except aifc.Error: print( "Error: file was not a valid AIFF file.\nIf you are exporting with Audacity 2.4 or later,\nplease use an earlier version (2.3.x or earlier)\nas AIFF exporting is broken." ) return False if a.getnchannels() > 1: print("Error: tool currently only supports mono audio.") return False return True
def test_write_params_singles(self): fout = aifc.open(io.BytesIO(), 'wb') fout.aifc() fout.setnchannels(1) fout.setsampwidth(2) fout.setframerate(3) fout.setnframes(4) fout.setcomptype('NONE', 'name') self.assertEqual(fout.getnchannels(), 1) self.assertEqual(fout.getsampwidth(), 2) self.assertEqual(fout.getframerate(), 3) self.assertEqual(fout.getnframes(), 0) self.assertEqual(fout.tell(), 0) self.assertEqual(fout.getcomptype(), 'NONE') self.assertEqual(fout.getcompname(), 'name') fout.writeframes('\x00' * 4 * fout.getsampwidth() * fout.getnchannels()) self.assertEqual(fout.getnframes(), 4) self.assertEqual(fout.tell(), 4)
def arrayToWAV(self, np1array, OPfname, nrchans=1, SR=44100, nrReps=0, gapSecs=0, buffsize=4096, trace=False): """ Writes npArray to fname.wav. Filename contains original DataFilename datetime-stamp. buffsize is size of wav write buffer. File writes are in buffsize increments. Write the arran nrReps number of times, with gapSec seconds between """ OPfileID = aifc.open(OPfname + '.wav', 'wb') # open the file and set up the header OPfileID.setnchannels(nrchans) # the number of channels (1=mono) OPfileID.setsampwidth(2) # the sample width in bytes(16bit fmt) OPfileID.setframerate(SR) # the frame rate. for mono, FR =SR # scale data -1 to 1 # scale (-1,1) the np.array, shift it 15 bits and overwrite it as int16s npSarray = BITS_15 * np1array # NB can be a np.array. Doesn't have 2B npSarray = npSarray.astype('int16') # cvt to 16 bit ints. # Use nparray.dtype say what type it is # to python list - has to be a better way!!!!! ## # try to pack it directly from the np1aray, as per pyAudioEg.py tmp = npSarray.tolist() dataString = "".join(struct.pack('>h', i) for i in tmp) # pack the array data into a buffer OPfileID.writeframes(dataString) # write buffer to file # if the sound it to be repeated,insert a gapsSec silence b4 writing again if nrReps > 0: tmp = np.array(np.zeros(gapSecs * SR * nrchans, dtype='int16')) silentString = "".join(struct.pack('>h', i) for i in tmp) # pack zeros into a buff for i in range(nrReps): OPfileID.writeframes(silentString) # write the silence buffer OPfileID.writeframes( dataString) # write the non-silent buffer again OPfileID.close() if trace: numsamps = int(len(np1array)) + (gapSecs * SR * nrchans) print("Wrote %s.wav, nrChans: %d, nrSamps: %d." % (OPfname, nrchans, numsamps))
def open (name, fh=0): name = os.path.normpath(name) if not os.path.exists(name): raise IOError, (2, "No such file or directory: '%s'" % name) ext = os.path.splitext(name)[1][1:].lower() if ext in ("mp4", "m4a", "m4b", "aac"): if os.name=="nt": cline = [faad, "-q", "-w", name] else: cline = [faad, "-q", "-f", "2", "-w", name] po = Popen(cline, shell=0, stdout=PIPE, stdin=PIPE, stderr=PIPE, creationflags=noWindow) po.stdin.close(); po.stderr.close() po.filename = name wf = fakewave(po, fh) elif ext=="ogg": if os.name=="nt": cline = [oggdec, "--stdout", name] else: cline = [oggdec, "-q", "-o", "-", name] po = Popen(cline, shell=0, stdout=PIPE, stdin=PIPE, stderr=PIPE, creationflags=noWindow) po.stdin.close(); po.stderr.close() po.filename = name wf = fakewave(po, fh) elif ext in ("wav", "wave"): wf = wave.open(name, "r") elif ext in ("aiff", "aif"): wf = aifc.open(name, "r") elif ext in ("mp1", "mp2", "mp3"): cline = [lame, "--quiet", "--decode", name, "-"] po = Popen(cline, shell=0, stdout=PIPE, stdin=PIPE, stderr=PIPE, creationflags=noWindow) po.stdin.close(); po.stderr.close() po.filename = name wf = fakewave(po, fh) elif ext in ("flac", "oga"): cline = [flac, "--silent", "--stdout", "-d", name] po = Popen(cline, shell=0, stdout=PIPE, stdin=PIPE, stderr=PIPE, creationflags=noWindow) po.stdin.close(); po.stderr.close() po.filename = name wf = fakewave(po, fh) elif ext=="wma": if os.name=="nt": cline = [wmadec, "-w", name] else: cline = [ffmpeg, "-i", name, "-f", "wav", "-"] po = Popen(cline, shell=0, stdout=PIPE, stdin=PIPE, stderr=PIPE, creationflags=noWindow) po.stdin.close(); po.stderr.close() po.filename = name wf = fakewave(po, fh) else: wf = None return wf
def readAudioFile(path): ''' This function returns a numpy array that stores the audio samples of a specified WAV of AIFF file ''' extension = os.path.splitext(path)[1] try: #if extension.lower() == '.wav': #[Fs, x] = wavfile.read(path) if extension.lower() == '.aif' or extension.lower() == '.aiff': s = aifc.open(path, 'r') nframes = s.getnframes() strsig = s.readframes(nframes) x = numpy.fromstring(strsig, numpy.short).byteswap() Fs = s.getframerate() elif extension.lower() == '.mp3' or extension.lower() == '.wav' or extension.lower() == '.au' or extension.lower() == '.ogg': try: audiofile = AudioSegment.from_file(path) #except pydub.exceptions.CouldntDecodeError: except: print("Error: file not found or other I/O error. " "(DECODING FAILED)") return (-1,-1) if audiofile.sample_width==2: data = numpy.fromstring(audiofile._data, numpy.int16) elif audiofile.sample_width==4: data = numpy.fromstring(audiofile._data, numpy.int32) else: return (-1, -1) Fs = audiofile.frame_rate x = [] for chn in list(range(audiofile.channels)): x.append(data[chn::audiofile.channels]) x = numpy.array(x) else: print("Error in readAudioFile(): Unknown file type!") return (-1,-1) except IOError: print("Error: file not found or other I/O error.") return (-1,-1) print("frame rate = {}, channel = {}".format(Fs,audiofile.channels)) return (x, Fs, audiofile.channels)
def readAudioFile(path, **kwargs): ''' This function returns a numpy array that stores the audio samples of a specified WAV of AIFF file ''' extension = kwargs.get('extension', os.path.splitext(path)[1].lower()) try: #if extension == '.wav': #[Fs, x] = wavfile.read(path) if extension in ['.aif', '.aiff']: s = aifc.open(path, 'r') nframes = s.getnframes() strsig = s.readframes(nframes) x = numpy.fromstring(strsig, numpy.short).byteswap() Fs = s.getframerate() else: try: audiofile = AudioSegment.from_file(path, **kwargs) #except pydub.exceptions.CouldntDecodeError: except: print("Error: file not found or other I/O error. " "(DECODING FAILED)") return (-1, -1) if audiofile.sample_width == 2: data = numpy.fromstring(audiofile._data, numpy.int16) elif audiofile.sample_width == 4: data = numpy.fromstring(audiofile._data, numpy.int32) else: return (-1, -1) Fs = audiofile.frame_rate x = [] for chn in list(range(audiofile.channels)): x.append(data[chn::audiofile.channels]) x = numpy.array(x).T except IOError: print("Error: file not found or other I/O error.") return (-1, -1) if x.ndim == 2: if x.shape[1] == 1: x = x.flatten() return (Fs, x)
def process_image(file_name): '''Retrieves time data from the aiff file and compute the spectogram for time_data''' if file_name.endswith('.aiff'): f = aifc.open(file_name, 'r') str_frames = f.readframes(f.getnframes()) Fs = f.getframerate() time_data = np.fromstring(str_frames, np.short).byteswap() f.close() Pxx, freqs, bins, im = plt.specgram(time_data,Fs=Fs,noverlap=90,cmap=plt.cm.gist_heat) from scipy.misc import imresize from sklearn import preprocessing if enlarge : Pxx_prep = imresize(np.log10(Pxx),(128,128), interp= 'lanczos').astype('float32') else: Pxx_prep = np.log(Pxx).astype.('float32') Pxx_ = preprocessing.StandardScaler().fit_transform(Pxx_prep) #rescale by std return Pxx_
def get_spec_par_halfoverlap(file): save_name = '../Spectrograms/spec_halfoverlap/' with aifc.open(file, 'r') as f: nframes = f.getnframes() strsig = f.readframes(nframes) data = numpy.fromstring(strsig, numpy.short).byteswap() nfft = 256 # Length of the windowing segments fs = 2 pxx, freqs, bins, im = plt.specgram(data, NFFT=nfft, Fs=fs, noverlap=64) plt.axis('off') plt.savefig( save_name + file[20:-5] + '.png', dpi=100, # Dots per inch frameon='false', aspect='normal', bbox_inches='tight', pad_inches=0) # Spectrogram saved as a .png
def test(): import aifc import EasyDialogs fn = EasyDialogs.AskFileForOpen(message="Select an AIFF soundfile", typeList=("AIFF", )) if not fn: return af = aifc.open(fn, 'r') print af.getparams() p = Play_Audio_mac() p.setoutrate(af.getframerate()) p.setsampwidth(af.getsampwidth()) p.setnchannels(af.getnchannels()) BUFSIZ = 10000 while 1: data = af.readframes(BUFSIZ) if not data: break p.writeframes(data) print 'wrote', len(data), 'space', p.getfillable() p.wait()
def get_spec_scipy(file): save_name = '../Spectrograms/scipy_spect/' save_name = 'C:\\Users\\jorge\\Desktop\\MAI\\scipy' with aifc.open(file, 'r') as f: nframes = f.getnframes() strsig = f.readframes(nframes) data = numpy.fromstring(strsig, numpy.short).byteswap() f, t, sxx = signal.spectrogram(data) plt.pcolormesh(t, f, sxx) plt.axis('off') plt.savefig( save_name + file[20:-5] + '.png', dpi=100, # Dots per inch frameon='false', aspect='normal', bbox_inches='tight', pad_inches=0) # Spectrogram saved as a .png plt.show() plt.close()
def test_aifc(h, f): with warnings.catch_warnings(): warnings.simplefilter('ignore', category=DeprecationWarning) import aifc if not h.startswith(b'FORM'): return None if h[8:12] == b'AIFC': fmt = 'aifc' elif h[8:12] == b'AIFF': fmt = 'aiff' else: return None f.seek(0) try: a = aifc.open(f, 'r') except (EOFError, aifc.Error): return None return (fmt, a.getframerate(), a.getnchannels(), a.getnframes(), 8 * a.getsampwidth())
def AIFF_to_Audio(filename): # when making changes, consider WAV_to_Audio as well import aifc with aifc.open(filename, "rb") as file: buffer = np.frombuffer(file.readframes(file.getnframes()), [np.uint8,np.int16,None,np.int32][file.getsampwidth()-1]) buffer = buffer.byteswap().astype(np.float64) # byte swap for AIFF only, not WAV buffer = np.reshape(buffer, newshape=(file.getnchannels(), int(len(buffer)/file.getnchannels()))[::-1]).T.copy(order='C') buffer /= 2**(8*file.getsampwidth()-1) from gensound.audio import Audio audio = Audio(file.getframerate()) audio.from_array(buffer) return audio
def test(fn=None): import sys if sys.argv[1:]: fn = sys.argv[1] else: fn = 'f:just samples:just.aif' import aifc af = aifc.open(fn, 'r') print fn, af.getparams() p = AudioDev() p.setoutrate(af.getframerate()) p.setsampwidth(af.getsampwidth()) p.setnchannels(af.getnchannels()) BUFSIZ = af.getframerate() / af.getsampwidth() / af.getnchannels() while 1: data = af.readframes(BUFSIZ) if not data: break print len(data) p.writeframes(data) p.wait()
def main(): decompFolder = os.path.expanduser(input("Enter decomp directory: ")) if not verify_decomp(decompFolder): return check_if_bank_exists(decompFolder) aiffPath = os.path.expanduser(input("Enter path for the .aiff file: ")) if not verify_aiff(aiffPath): return a = aifc.open(aiffPath, "r") print("\nAIFF data:\n\tSample rate: %dHZ\n\tTotal samples: %d\n\tLength: %.1f seconds\n" % (a.getframerate(), a.getnframes(), a.getnframes()/a.getframerate())) if (a.getframerate() > 32000): ans = input("Warning: sample rate (%dHZ) exceeds recommended rate of 32000HZ.\nConsider reducing sample rate to save space.\nContinue? (y/n) ") if ans.upper() != "Y": return name = input("Enter a name for the streamed audio: ") if not verify_name(name): return add_streamed_audio(aiffPath, name, decompFolder)
def __init__(self, path, speed=1, interp=2, mul=1, add=0): PyoObject.__init__(self, mul, add) self._speed = speed self._interp = interp path, speed, interp, mul, add, lmax = convertArgsToLists(path, speed, interp, mul, add) self._base_players = [] self._base_objs = [] self._snd_size, self._dur, self._snd_sr, self._snd_chnls, _format, _type = sndinfo(path[0]) for i in range(lmax): try: sf = aifc.open(wrap(path,i)) markerstmp = sf.getmarkers() sf.close() self._markers = [m[1] for m in markerstmp] except: self._markers = [] self._base_players.append(SfMarkerShuffler_base(wrap(path,i), self._markers, wrap(speed,i), wrap(interp,i))) for i in range(lmax * self._snd_chnls): j = i / self._snd_chnls self._base_objs.append(SfMarkerShuffle_base(wrap(self._base_players,j), i % self._snd_chnls, wrap(mul,j), wrap(add,j)))
def open_audio(file): _, ext = os.path.splitext(os.path.basename(file)) ext = ext.lower() # if ext in (".wav", ".wave"): # import wave # return wave.open(file, "rb"), 'little', 128 if ext in (".aiff", ".aifc", ".aif"): import aifc return aifc.open(file, "rb"), 'big', 'AIFF' if ext in (".au", ".snd"): import sunau return sunau.open(file, "rb"), 'big', 'SUN' # default import wave return wave.open(file, "rb"), 'little', 'WAVE'
def readAudio(self, filePath): fileName, fileExtension = splitext(filePath) self.fileExtension = fileExtension if self.fileExtension == '.wav': self.sampleRate, self.data = read(filePath) elif self.fileExtension == '.aif': file = aifc.open(filePath) self.sampleRate = float(file.getframerate()) numFrames = file.getnframes() self.data = file.readframes(numFrames) file.close() elif self.fileExtension == '.pcm': rawData = np.memmap(filePath, dtype='h', mode='r') self.data = np.asarray(rawData) else: raise AttributeError("Invalid file type")
def test_read(self): f = self.f = aifc.open(self.sndfilepath) self.assertEqual(f.readframes(0), b'') self.assertEqual(f.tell(), 0) self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4') f.rewind() pos0 = f.tell() self.assertEqual(pos0, 0) self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4') pos2 = f.tell() self.assertEqual(pos2, 2) self.assertEqual(f.readframes(2), b'\x17t\x17t"\xad"\xad') f.setpos(pos2) self.assertEqual(f.readframes(2), b'\x17t\x17t"\xad"\xad') f.setpos(pos0) self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4') with self.assertRaises(aifc.Error): f.setpos(-1) with self.assertRaises(aifc.Error): f.setpos(f.getnframes() + 1)
def readAudioFile(path): ''' This function returns a numpy array that stores the audio samples of a specified WAV of AIFF file ''' extension = os.path.splitext(path)[1] try: # if extension.lower() == '.wav': #[Fs, x] = wavfile.read(path) if extension.lower() == '.aif' or extension.lower() == '.aiff': s = aifc.open(path, 'r') nframes = s.getnframes() strsig = s.readframes(nframes) x = numpy.fromstring(strsig, numpy.short).byteswap() Fs = s.getframerate() elif extension.lower() == '.mp3' or extension.lower() == '.wav' or extension.lower() == '.au': audiofile = AudioSegment.from_file(path) if audiofile.sample_width == 2: data = numpy.fromstring(audiofile._data, numpy.int16) elif audiofile.sample_width == 4: data = numpy.fromstring(audiofile._data, numpy.int32) else: return (-1, -1) Fs = audiofile.frame_rate x = [] for chn in range(audiofile.channels): x.append(data[chn::audiofile.channels]) x = numpy.array(x).T else: print("Error in readAudioFile(): Unknown file type!") return (-1, -1) except IOError as e: print("Error: file not found or other I/O error.", e) return (-1, -1) if x.ndim == 2: if x.shape[1] == 1: x = x.flatten() return (Fs, x)
def __init__(self, filename): self._fh = open(filename, 'rb') try: self._file = aifc.open(self._fh) except aifc.Error: # Return to the beginning of the file to try the WAV reader. self._fh.seek(0) else: self._is_aif = True return try: self._file = wave.open(self._fh) except wave.Error: pass else: self._is_aif = False return raise UnsupportedError()
def test_flac_load(self): r = sr.Recognizer() with sr.AudioFile(self.AUDIO_FILE_FLAC) as source: audio = r.record(source) self.assertIsInstance(audio, sr.AudioData) process = subprocess.Popen([ sr.get_flac_converter(), "--stdout", "--totally-silent", "--decode", "--force-aiff-format", self.AUDIO_FILE_FLAC ], stdout=subprocess.PIPE) aiff_data, _ = process.communicate() aiff_file = io.BytesIO(aiff_data) audio_reader = aifc.open(aiff_file, "rb") self.assertEqual(audio.sample_rate, audio_reader.getframerate()) self.assertEqual(audio.sample_width, audio_reader.getsampwidth()) aiff_data = audio_reader.readframes(audio_reader.getnframes()) aiff_data_little_endian = aiff_data[1::-1] + b"".join( aiff_data[i + 2:i:-1] for i in range(1, len(aiff_data), 2)) self.assertEqual(audio.get_raw_data(), aiff_data_little_endian) audio_reader.close() aiff_file.close()
def main(): import getopt, string try: opts, args = getopt.getopt(sys.argv[1:], 'o:p:') except getopt.error: sys.stderr.write('Usage ' + sys.argv[0] + ' [ -o outfile ] [ args ] ...\n') sys.exit(1) dev = None for o, a in opts: if o == '-o': import aifc dev = aifc.open(a, 'w') dev.setframerate(44100) dev.setsampwidth(2) dev.setnchannels(1) if o == '-p': mkwave(string.atoi(a)) if not dev: import audiodev dev = audiodev.AudioDev() dev.setoutrate(44100) dev.setsampwidth(2) dev.setnchannels(1) dev.close = dev.stop dev.writeframesraw = dev.writeframes if args: line = string.join(args) else: line = sys.stdin.readline() while line: mline = morse(line) play(mline, dev) if hasattr(dev, 'wait'): dev.wait() if not args: line = sys.stdin.readline() else: line = '' dev.close()
def main(args=sys.argv[1:]): import getopt, string try: opts, args = getopt.getopt(args, 'o:p:') except getopt.error: sys.stderr.write('Usage ' + sys.argv[0] + ' [ -o outfile ] [ args ] ...\n') sys.exit(1) dev = None for o, a in opts: if o == '-o': import aifc dev = aifc.open(a, 'w') dev.setframerate(FRAMERATE) dev.setsampwidth(SAMPWIDTH) dev.setnchannels(1) if o == '-p': mkwave(string.atoi(a)) if not dev: dev = BufferedAudioDev() dev.setoutrate(FRAMERATE) dev.setsampwidth(SAMPWIDTH) dev.setnchannels(1) dev.close = dev.stop if args: line = string.join(args) else: line = sys.stdin.readline() while line: print line mline = morse(line) print mline play(mline, dev) if hasattr(dev, 'wait'): dev.wait() if not args: line = sys.stdin.readline() else: line = '' dev.close()
def read(file): """ Read a AIFC file. Parameters ---------- file : string or file object Either the name of a file or an open file pointer. Returns ------- wav : aifcio.Aifc() instance The return value is an instance of the class `wavio.Wav`, with the following attributes: data : numpy array The array containing the data. The shape of the array is (num_samples, num_channels). num_channels is the number of audio channels (1 for mono, 2 for stereo). rate : float The sampling frequency (i.e. frame rate) sampwidth : float The sample width, in bytes. E.g. for a 24 bit AIFC file, sampwidth is 3. Notes ----- This function uses the `wave` module of the Python standard libary to read the AIFC file, so it has the same limitations as that library. In particular, the function does not read files with floating point data. The array returned by `aifcio.read` is alway two-dimensional. If the AIFC data is mono, the array will have shape (num_samples, 1). """ aif = _aifc.open(file) rate = aif.getframerate() nchannels = aif.getnchannels() sampwidth = aif.getsampwidth() nframes = aif.getnframes() data = aif.readframes(nframes) aif.close() array = _aifc2array(nchannels, sampwidth, rate, data) a = Aifc(data=array, rate=rate, sampwidth=sampwidth) # print(a) return a
def all_glyphs_in_one_aiff(): # all tones after another f = CurrentFont() a = aifc.open("aiff_out/aiffContours.aiff", "wb") a.setnchannels(1) a.setsampwidth(4) a.setframerate(44100) m = 0 for n in f.selection: g = f[n] flattenGlyph(g, 4) print g.name m += 1 a.setmark(m, a.tell(), g.name) cDists = {} for i in range(len(g)): cList = [] c = g[i] b = c.box if b is None: # ignore anchors, they have no bounding box break pCenter = ((b[0] + b[2]) / 2, (b[1] + b[3]) / 2) for p in c.points: cList.append(distance(pCenter, (p.x, p.y), doRound=True)) cDists[i] = cList amps = {} for k, myList in cDists.iteritems(): amps[k] = scaleList(myList, 255) for k, v in amps.iteritems(): print k #print v for i in range(100): for myVal in v: a.writeframes(pack("i", myVal)) myVal = pack("i", 0) for i in range(10000): a.writeframes(myVal) a.close() print "Done."
def process_image(file_name, enlarge=True, image_height=129, image_width=23): '''Retrieves time data from the aiff file and compute the spectogram for time_data''' '''enlarge: gives option to resize the image to new dimensions WxH by interpolation''' if file_name.endswith('.aiff'): f = aifc.open(file_name, 'r') str_frames = f.readframes(f.getnframes()) Fs = f.getframerate() time_data = np.fromstring(str_frames, np.short).byteswap() f.close() Pxx, freqs, bins, im = plt.specgram(time_data, NFFT=256, Fs=Fs, noverlap=90, cmap=plt.cm.gist_heat) Pxx = Pxx[[freqs < 250.]] # Right-whales call occur under 250Hz #print Pxx.shape from scipy.misc import imresize from sklearn import preprocessing if enlarge: #change image size #Pxx_prep = imresize(np.log10(Pxx),(image_height,image_width), interp= 'lanczos').astype('float32') Pxx_prep = imresize(Pxx, (image_height, image_width), interp='lanczos').astype('float32') else: #image size not changed Pxx_prep = np.log(Pxx).astype('float32') #Pxx_prep = preprocessing.MinMaxScaler().fit_transform(Pxx_prep) #rescale to 0-1 Pxx_prep = preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True).fit_transform( Pxx_prep) #rescale by std Pxx_ = (Pxx_prep * 255.0).astype(int) # Returning raw values to perform operations. Used to obtain raw data for ipynb #Pxx_ = Pxx_prep #Pxx_ = Pxx return Pxx_ else: print("Error in file: " + file_name + "...\n") pass
def test_params(self): f = self.f = aifc.open(self.sndfilepath) params = f.getparams() self.assertEqual(f.getfp().name, self.sndfilepath) self.assertEqual(f.getnchannels(), 2) self.assertEqual(f.getsampwidth(), 2) self.assertEqual(f.getframerate(), 48000) self.assertEqual(f.getnframes(), 14400) self.assertEqual(f.getcomptype(), b'NONE') self.assertEqual(f.getcompname(), b'not compressed') self.assertEqual( f.getparams(), (2, 2, 48000, 14400, b'NONE', b'not compressed'), ) params = f.getparams() self.assertEqual(params.nchannels, 2) self.assertEqual(params.sampwidth, 2) self.assertEqual(params.framerate, 48000) self.assertEqual(params.nframes, 14400) self.assertEqual(params.comptype, b'NONE') self.assertEqual(params.compname, b'not compressed')
def readAudioFile(path): ''' This function returns a numpy array that stores the audio samples of a specified WAV of AIFF file ''' extension = os.path.splitext(path)[1] try: if extension.lower() == '.wav': [Fs, x] = wavfile.read(path) elif extension.lower() == '.aif' or extension.lower() == '.aiff': s = aifc.open(path, 'r') nframes = s.getnframes() strsig = s.readframes(nframes) x = numpy.fromstring(strsig, numpy.short).byteswap() Fs = s.getframerate() else: print "Error in readAudioFile(): Unknown file type!" return (-1,-1) except IOError: print "Error: file not found or other I/O error." return (-1,-1) return (Fs, x)
def makesound(fl): """makesound(fl) -> None Generate AIFF sound data for a short musical note, and write the AIFF to the given file. """ import aifc, math afl = aifc.open(fl, 'wb') afl.setnchannels(2) afl.setsampwidth(2) afl.setframerate(22050) nframes = 5000 ratio = (0.5 * math.pi / nframes) for ix in range(nframes): amp = 0.5 * (math.sin(ix * 0.10) + math.sin(ix * 0.166666)) amp *= math.cos(ix * ratio) if (ix < 10): amp *= (ix * 0.1) amp = int(amp * 0x4000) dat = chr((amp >> 8) & 0xFF) + chr(amp & 0xFF) amp = amp // 10 dat += chr((amp >> 8) & 0xFF) + chr(amp & 0xFF) afl.writeframes(dat) afl.close()