def testminmax(data):
if verbose:
print 'minmax'
if audioop.minmax(data[0], 1) != (0, 2) or \
audioop.minmax(data[1], 2) != (0, 2) or \
audioop.minmax(data[2], 4) != (0, 2):
return 0
return 1
def testminmax(data):
if verbose:
print 'minmax'
if audioop.minmax(data[0], 1) <> (0, 2) or \
audioop.minmax(data[1], 2) <> (0, 2) or \
audioop.minmax(data[2], 4) <> (0, 2):
return 0
return 1
def minmax(self):
"""Return the (minimum,maximum) of the values of all frames.
:returns (min,max)
"""
return audioop.minmax(self._frames, self._sampwidth)
def _write_frames_to_file(self, frames, framerate, volume):
with tempfile.NamedTemporaryFile(
mode='w+b',
suffix=".wav",
prefix=datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) as f:
wav_fp = wave.open(f, 'wb')
wav_fp.setnchannels(self._input_device._input_channels)
wav_fp.setsampwidth(int(self._input_device._input_bits / 8))
wav_fp.setframerate(framerate)
if self._input_device._input_rate == framerate:
fragment = b''.join(frames)
else:
fragment = audioop.ratecv(
''.join(frames), int(self._input_device._input_bits / 8),
self._input_device._input_channels,
self._input_device._input_rate, framerate, None)[0]
if volume is not None:
maxvolume = audioop.minmax(
fragment, self._input_device._input_bits / 8)[1]
fragment = audioop.mul(fragment,
int(self._input_device._input_bits / 8),
volume * (2.**15) / maxvolume)
wav_fp.writeframes(fragment)
wav_fp.close()
f.seek(0)
yield f
def minmax(self):
""" Return the (minimum,maximum) of the values of all frames.
:returns (min,max)
"""
return audioop.minmax(self._frames, self._sampwidth)
def max(self):
"""
Return the maximum of the values of all frames.
@return the maximum
"""
return audioop.minmax(self.frames, self.sampwidth)[1]
def test_minmax(self):
for w in 1, 2, 3, 4:
self.assertEqual(audioop.minmax(b"", w), (0x7FFFFFFF, -0x80000000))
self.assertEqual(audioop.minmax(bytearray(), w), (0x7FFFFFFF, -0x80000000))
self.assertEqual(audioop.minmax(memoryview(b""), w), (0x7FFFFFFF, -0x80000000))
p = packs[w]
self.assertEqual(audioop.minmax(p(5), w), (5, 5))
self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
self.assertEqual(audioop.minmax(p(maxvalues[w]), w), (maxvalues[w], maxvalues[w]))
self.assertEqual(audioop.minmax(p(minvalues[w]), w), (minvalues[w], minvalues[w]))
self.assertEqual(audioop.minmax(datas[w], w), (minvalues[w], maxvalues[w]))
def run(self):
i = 0
while True:
if self.muted != True:
dataLen, data = self.input.read()
#dataLen = AUDIO_LEN
#data = self.wav.readframes(AUDIO_LEN)
if dataLen == AUDIO_LEN:
smin, smax = audioop.minmax(data, MUMBLE_SAMPLESIZE)
if smax - smin > self.silence:
captureQueue.put(data)
def test_minmax(self):
for w in 1, 2, 3, 4:
self.assertEqual(audioop.minmax(b'', w), (0x7fffffff, -0x80000000))
self.assertEqual(audioop.minmax(bytearray(), w),
(0x7fffffff, -0x80000000))
self.assertEqual(audioop.minmax(memoryview(b''), w),
(0x7fffffff, -0x80000000))
p = packs[w]
self.assertEqual(audioop.minmax(p(5), w), (5, 5))
self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
self.assertEqual(audioop.minmax(p(maxvalues[w]), w),
(maxvalues[w], maxvalues[w]))
self.assertEqual(audioop.minmax(p(minvalues[w]), w),
(minvalues[w], minvalues[w]))
self.assertEqual(audioop.minmax(datas[w], w),
(minvalues[w], maxvalues[w]))
def test_minmax(self):
for w in (1, 2, 3, 4):
self.assertEqual(audioop.minmax(b'', w), (2147483647, -2147483648))
self.assertEqual(audioop.minmax(bytearray(), w),
(2147483647, -2147483648))
self.assertEqual(audioop.minmax(memoryview(b''), w),
(2147483647, -2147483648))
p = packs[w]
self.assertEqual(audioop.minmax(p(5), w), (5, 5))
self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
self.assertEqual(audioop.minmax(p(maxvalues[w]), w),
(maxvalues[w], maxvalues[w]))
self.assertEqual(audioop.minmax(p(minvalues[w]), w),
(minvalues[w], minvalues[w]))
self.assertEqual(audioop.minmax(datas[w], w),
(minvalues[w], maxvalues[w]))
def write_frames_to_file(frames, volume=None):
with tempfile.NamedTemporaryFile(suffix='.wav', mode='w+b') as f:
wav_fp = wave.open(f, 'wb')
wav_fp.setnchannels(1)
wav_fp.setsampwidth(2)
wav_fp.setframerate(16000)
fragment = b''.join(frames)
if volume is not None:
maxvolume = audioop.minmax(fragment, 2)[1]
fragment = audioop.mul(fragment, 2, volume * (2.**15) / maxvolume)
wav_fp.writeframes(fragment)
wav_fp.close()
f.seek(0)
yield f
def calculate_max_min(self):
self.Sound.write(".temp.wav")
S = wave.open(".temp.wav","rb")
Length = S.getnframes()
BufferLen = Length / self.FragmentFactor
Stream = S.readframes(BufferLen)
while len(Stream) :
Stream = audioop.lin2lin(Stream,2,1)
Stream = audioop.tomono(Stream,1,1,-1)
min_val, max_val = audioop.minmax(Stream, 1)
self.Min_List.append(min_val)
self.Max_List.append(max_val)
Stream = S.readframes(BufferLen)
S.close()
os.remove(".temp.wav")
def update(self, task):
if self.cursor.ready() >= 16:
data = self.cursor.readSamples(self.cursor.ready())
rms = audioop.rms(data, 2)
minmax = audioop.minmax(data, 2)
intensity = float(rms) / 32767.0
self.win.setClearColor(Vec4(intensity, intensity, intensity, 1))
print rms, minmax
currentZ = self.smiley.getZ()
self.smiley.setZ(currentZ - 0.3 + intensity)
if self.smiley.getZ() <= 1:
self.smiley.setZ(1)
return task.cont
def run(self):
while True:
if self.muted != True:
dataLen, data = self.input.read()
if dataLen == self.AUDIO_LEN:
smin, smax = audioop.minmax(data, self.MUMBLE_SAMPLESIZE)
if smax - smin > self.silence:
data, state = audioop.ratecv(data,
self.MUMBLE_SAMPLESIZE,
self.MUMBLE_CHANNELS,
self.inputRate,
self.MUMBLE_RATE, None)
data = audioop.mul(data, self.MUMBLE_CHANNELS,
self.digitalVol)
self.client.sound_output.add_sound(data)
while self.client.sound_output.get_buffer_size() > 0.5:
time.sleep(0.01)
def get_minmax_tag(self):
min_list = []
max_list = []
self.write(".temp.wav")
Song = wave.open(".temp.wav", "rb")
NumStream = Song.getnframes()
BufferLen = NumStream / self.FragmentFactor
Stream = Song.readframes(BufferLen)
while len(Stream):
Stream = Audio.lin2lin(Stream, 2, 1)
Stream = Audio.tomono(Stream, 1, 1, -1)
min_val, max_val = Audio.minmax(Stream, self.ByteLength)
min_list.append(min_val)
max_list.append(max_val)
Stream = Song.readframes(BufferLen)
Song.close()
os.remove(".temp.wav")
return min_list, max_list
def get_minmax_tag(self):
min_list = []
max_list = []
self.write(".temp.wav")
Song = wave.open(".temp.wav","rb")
NumStream = Song.getnframes()
BufferLen = NumStream / self.FragmentFactor
Stream = Song.readframes(BufferLen)
while len(Stream):
Stream = Audio.lin2lin(Stream,2,1)
Stream = Audio.tomono(Stream,1,1,-1)
min_val, max_val = Audio.minmax(Stream, self.ByteLength)
min_list.append(min_val)
max_list.append(max_val)
Stream = Song.readframes(BufferLen)
Song.close()
os.remove(".temp.wav")
return min_list, max_list
def test_minmax(self):
for w in 1, 2, 4:
self.assertEqual(audioop.minmax(b'', w),
(0x7fffffff, -0x80000000))
p = packs[w]
self.assertEqual(audioop.minmax(p(5), w), (5, 5))
self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
self.assertEqual(audioop.minmax(p(maxvalues[w]), w),
(maxvalues[w], maxvalues[w]))
self.assertEqual(audioop.minmax(p(minvalues[w]), w),
(minvalues[w], minvalues[w]))
self.assertEqual(audioop.minmax(datas[w], w),
(minvalues[w], maxvalues[w]))
def feed(self, *blocks):
mix = blocks[0]
remaining = list(blocks[1:])
while remaining:
mix = audioop.add(mix, remaining.pop(), self.params.sampwidth)
self.buffered_blocks.append(mix)
if len(self.buffered_blocks) == 4:
block = ''.join(self.buffered_blocks)
self.buffered_blocks = []
minval, maxval = audioop.minmax(block, self.params.sampwidth)
minval = minval * self.headroom / self.params.scale
maxval = maxval * self.headroom / self.params.scale
self.canvas.coords(self.lines[self.pos], self.pos, self.middle-minval, self.pos, self.middle-maxval)
self.pos = (self.pos + 1) % self.width
def decode_ltc(wave_frames):
global jam
frames = []
output = ''
out2 = ''
last = None
toggle = True
sp = 1
first = True
for i in range(0, len(wave_frames), 2):
data = wave_frames[i:i + 2]
pos = audioop.minmax(data, 2)
if pos[0] < 0:
cyc = 'Neg'
else:
cyc = 'Pos'
if cyc != last:
if sp >= 7:
out2 = 'Samples: ' + str(sp) + ' ' + cyc + '\n'
if sp > 14:
bit = '0'
output += str(bit)
else:
if toggle:
bit = '1'
output += str(bit)
toggle = False
else:
toggle = True
if len(output) >= len(SYNC_WORD):
if output[-len(SYNC_WORD):] == SYNC_WORD:
if len(output) > 80:
frames.append(output[-80:])
output = ''
#os.system('clear')
#print('Jam received:',decode_frame(frames[-1])['formatted_tc'])
jam = decode_frame(frames[-1])['formatted_tc']
sp = 1
last = cyc
else:
sp += 1
def _write_frames_to_file(self, frames, framerate):
with tempfile.NamedTemporaryFile(mode='w+b') as f:
wav_fp = wave.open(f, 'wb')
wav_fp.setnchannels(self._input_channels)
wav_fp.setsampwidth(int(self._input_bits / 8))
wav_fp.setframerate(framerate)
if self._input_rate == framerate:
fragment = ''.join(frames)
else:
fragment = audioop.ratecv(''.join(frames),
int(self._input_bits / 8),
self._input_channels,
self._input_rate, framerate, None)[0]
maxvolume = audioop.minmax(fragment, self._input_bits / 8)[1]
fragment_norm = audioop.mul(fragment, int(self._input_bits / 8),
0.5 * (2.**15) / maxvolume)
wav_fp.writeframes(fragment_norm)
wav_fp.close()
f.seek(0)
yield f
url = "http://localhost:6680/mopidy/rpc"
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, "hw:1,0")
inp.setchannels(1)
inp.setrate(8000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
inp.setperiodsize(640)
while True:
# Read data from device
l,data = inp.read()
if l:
# calculate the biggest difference
minmax = audioop.minmax(data, 2)
diff = (minmax[0] - minmax[1]) * -1
if diff <= threshold:
currentState = False
else:
currentState = True
if currentState != lastState:
method = ""
if currentState == True:
method = "core.playback.play"
else:
method = "core.playback.pause"
#! /usr/bin/env python
import alsaaudio, audioop, time
if __name__=="__main__":
#Copypaste from https://stackoverflow.com/questions/1936828/how-get-sound-input-from-microphone-in-python-and-process-it-on-the-fly
inp=alsaaudio.PCM(alsaaudio.PCM_CAPTURE,alsaaudio.PCM_NONBLOCK)
inp.setchannels(1)
inp.setrate(8000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
inp.setperiodsize(160)
minim=10**10
maxim=-10**10
while True:
l,data=inp.read()
if l:
ignore,outd=audioop.minmax(data, 2)
minim=outd if outd<minim else minim
maxim=outd if outd>maxim else maxim
print "\rMAX %i | MIN %i"%(maxim,minim),
time.sleep(.001)
# Downloading an audio file from s3 to local system
bucket.download_file('****{wave file URL ob s3}****.wav',
r'../path_for_local_system/recording.wav')
with open(r'../../decibel_values.csv', 'a') as f:
f.write('recording_name', 'sample_width', 'n_frames', 'avg', 'rms',
'avgpp', 'zero_crossings', 'maxpp', 'min_max')
f.write(
str(a, wav.getsampwidth(), wav.getnframes(),
audioop.avg(string_wav, wav.getsampwidth()),
audioop.rms(string_wav, wav.getsampwidth()),
audioop.avgpp(string_wav, wav.getsampwidth()),
audioop.cross(string_wav, wav.getsampwidth()),
audioop.maxpp(string_wav, wav.getsampwidth()),
audioop.minmax(string_wav, wav.getsampwidth())))
wav = wave.open(r'../../recordings.wav')
string_wav = wav.readframes(wav.getnframes())
print('getsampwidth', wav.getsampwidth())
print('get n frmaes', wav.getnframes())
print('avg: ', audioop.avg(string_wav, wav.getsampwidth()))
print('rms: ', audioop.rms(string_wav, wav.getsampwidth()))
print('avgpp: ', audioop.avgpp(string_wav, wav.getsampwidth()))
print('zero_crossings: ', audioop.cross(string_wav, wav.getsampwidth()))
print('maxpp: ', audioop.maxpp(string_wav, wav.getsampwidth()))
print('max min: ', audioop.minmax(string_wav, wav.getsampwidth()))
def min(self):
""" Return the minimum of the values of all frames. """
return audioop.minmax(self._frames, self._sampwidth)[0]
def max(self):
"""Return the maximum of the values of all frames."""
return audioop.minmax(self._frames, self._sampwidth)[1]
def test_minmax(self):
self.assertEqual(audioop.minmax(data[0], 1), (0, 2))
self.assertEqual(audioop.minmax(data[1], 2), (0, 2))
self.assertEqual(audioop.minmax(data[2], 4), (0, 2))
def _extract_fragment_data(self, fragment):
arms = audioop.rms(fragment, 2)
amin, amax = audioop.minmax(fragment, 2)
return [('gauge', 'sound.min', amin),
('gauge', 'sound.max', amax),
('gauge', 'sound.rms', arms)]
def test_minmax(self):
self.assertEqual(audioop.minmax(data[0], 1), (0, 2))
self.assertEqual(audioop.minmax(data[1], 2), (0, 2))
self.assertEqual(audioop.minmax(data[2], 4), (0, 2))
buttons,
text="update",
command=lambda t=nameform.get(): updatename(nameform.get()))
nameform.pack()
submitname.pack(fill="x")
startbutton.pack(fill="x")
stopbutton.pack(fill="x")
# Main loop
try:
while True:
#Get new audio data
l, data = inp.read()
if l:
try:
z, outd = audioop.minmax(data, 2)
except audioop.error:
outd = 0
# Update chrono widnow
now = time.time()
if countstarted:
if now - previoustick > 1:
countdown[1] -= 1
if countdown[1] == -1:
countdown[1] = 59
countdown[0] -= 1
previoustick = time.time()
if not countdown[0] and not countdown[1]:
stopf()
stopbutton=Tkinter.Button(buttons, text="Stop", background="#BB0000", foreground="white", command=stopf)
nameform=Tkinter.Entry(buttons)
submitname=Tkinter.Button(buttons, text="update", command=lambda t=nameform.get():updatename(nameform.get()))
nameform.pack()
submitname.pack(fill="x")
startbutton.pack(fill="x")
stopbutton.pack(fill="x")
# Main loop
try:
while True:
#Get new audio data
l,data=inp.read()
if l:
try:
z,outd=audioop.minmax(data, 2)
except audioop.error:
outd=0
# Update chrono widnow
now=time.time()
if countstarted:
if now-previoustick>1:
countdown[1]-=1
if countdown[1]==-1:
countdown[1]=59
countdown[0]-=1
previoustick=time.time()
if not countdown[0] and not countdown[1]:
stopf()
#! /usr/bin/env python
import alsaaudio, audioop, time
if __name__ == "__main__":
#Copypaste from https://stackoverflow.com/questions/1936828/how-get-sound-input-from-microphone-in-python-and-process-it-on-the-fly
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NONBLOCK)
inp.setchannels(1)
inp.setrate(8000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
inp.setperiodsize(160)
minim = 10**10
maxim = -10**10
while True:
l, data = inp.read()
if l:
ignore, outd = audioop.minmax(data, 2)
minim = outd if outd < minim else minim
maxim = outd if outd > maxim else maxim
print "\rMAX %i | MIN %i" % (maxim, minim),
time.sleep(.001)
