Merge pull request #1 from StormFox23/mic

Mic

Author: StormFox23

.gitignore

@@ -5,7 +5,7 @@ __pycache__/
 
 # C extensions
 *.so
-
+mic/file.wav
 # Distribution / packaging
 .Python
 build/

mic/mic_wave.py

@@ -0,0 +1,93 @@
+try:
+    import pyaudio
+    import numpy as np
+    import pylab
+    import matplotlib.pyplot as plt
+    from scipy.io import wavfile
+    import time
+    import sys
+    # import seaborn as sns
+except:
+    print("error import")
+
+i = 0
+f, ax = plt.subplots(2)
+
+x = np.arange(10000)
+y = np.random.randn(10000)
+
+li, = ax[0].plot(x, y)
+ax[0].set_xlim(0, 1000)
+ax[0].set_ylim(-5000, 5000)
+ax[0].set_title("Raw Audio Signal")
+
+li2, = ax[1].plot(x, y)
+ax[1].set_xlim(0, 5000)
+ax[1].set_ylim(-100, 100)
+ax[1].set_title("Fast Fourier Transform (FFT)")
+
+plt.pause(0.01)
+plt.tight_layout()
+
+FORMAT = pyaudio.paInt16  # We use 16bit format per sample
+CHANNELS = 1
+RATE = 44100
+CHUNK = 1024  # 1024bytes of data red from a buffer
+RECORD_SECONDS = 0.1
+WAVE_OUTPUT_FILENAME = "file.wav"
+
+audio = pyaudio.PyAudio()
+
+# start Recording
+stream = audio.open(format=FORMAT,
+                    channels=CHANNELS,
+                    rate=RATE,
+                    input=True)  # ,
+# frames_per_buffer=CHUNK)
+
+global keep_going
+keep_going = True
+
+
+def plot_data(in_data):
+    # get and convert the data to float
+    audio_data = np.frombuffer(in_data, np.int16)
+    # Fast Fourier Transform, 10*log10(abs) is to scale it to dB
+    # and make sure it's not imaginary
+    dfft = 10. * np.log10(abs(np.fft.rfft(audio_data)))
+
+    # Force the new data into the plot, but without redrawing axes.
+    # If uses plt.draw(), axes are re-drawn every time
+    # print audio_data[0:10]
+    # print dfft[0:10]
+    # print
+    li.set_xdata(np.arange(len(audio_data)))
+    li.set_ydata(audio_data)
+    li2.set_xdata(np.arange(len(dfft)) * 10.)
+    li2.set_ydata(dfft)
+
+    # Show the updated plot, but without blocking
+    plt.pause(0.01)
+    if keep_going:
+        return True
+    else:
+        return False
+
+
+stream.start_stream()
+print("\n+---------------------------------+")
+print("| Premi Ctrl+C per terminare |")
+print("+---------------------------------+\n")
+
+while keep_going:
+    try:
+        plot_data(stream.read(CHUNK))
+    except KeyboardInterrupt:
+        keep_going = False
+    except:
+        pass
+
+stream.stop_stream()
+stream.close()
+
+audio.terminate()

mic/record_wave.py

@@ -0,0 +1,35 @@
+import pyaudio
+import wave
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 2
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "file.wav"
+
+audio = pyaudio.PyAudio()
+
+# start Recording
+stream = audio.open(format=FORMAT, channels=CHANNELS,
+                    rate=RATE, input=True,
+                    frames_per_buffer=CHUNK)
+print("recording...")
+frames = []
+
+for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+    data = stream.read(CHUNK)
+    frames.append(data)
+print("finished recording")
+
+# stop Recording
+stream.stop_stream()
+stream.close()
+audio.terminate()
+
+waveFile = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+waveFile.setnchannels(CHANNELS)
+waveFile.setsampwidth(audio.get_sample_size(FORMAT))
+waveFile.setframerate(RATE)
+waveFile.writeframes(b''.join(frames))
+waveFile.close()

mic/server/client.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+import pyaudio
+import socket
+import sys
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 4096
+
+s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+s.connect((sys.argv[1], int(sys.argv[2])))
+audio = pyaudio.PyAudio()
+stream = audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, output=True, frames_per_buffer=CHUNK)
+
+try:
+    while True:
+        data = s.recv(CHUNK)
+        stream.write(data)
+except KeyboardInterrupt:
+    pass
+
+print('Shutting down')
+s.close()
+stream.close()
+audio.terminate()

mic/server/server.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import pyaudio
+import socket
+import select
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 4096
+
+audio = pyaudio.PyAudio()
+
+serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+serversocket.bind(('', 4444))
+serversocket.listen(5)
+
+
+def callback(in_data, frame_count, time_info, status):
+    for s in read_list[1:]:
+        s.send(in_data)
+    return (None, pyaudio.paContinue)
+
+
+# start Recording
+stream = audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK, stream_callback=callback)
+# stream.start_stream()
+
+read_list = [serversocket]
+print("recording...")
+
+try:
+    while True:
+        readable, writable, errored = select.select(read_list, [], [])
+        for s in readable:
+            if s is serversocket:
+                (clientsocket, address) = serversocket.accept()
+                read_list.append(clientsocket)
+                print("Connection from", address)
+            else:
+                data = s.recv(1024)
+                if not data:
+                    read_list.remove(s)
+except KeyboardInterrupt:
+    pass
+
+
+print("finished recording")
+
+serversocket.close()
+# stop Recording
+stream.stop_stream()
+stream.close()
+audio.terminate()

mic/vad.py

@@ -0,0 +1,150 @@
+'''
+Requirements:
++ pyaudio - `pip install pyaudio`
++ py-webrtcvad - `pip install webrtcvad`
+'''
+import webrtcvad
+import collections
+import sys
+import signal
+import pyaudio
+
+from array import array
+from struct import pack
+import wave
+import time
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 16000
+CHUNK_DURATION_MS = 30       # supports 10, 20 and 30 (ms)
+PADDING_DURATION_MS = 1500   # 1 sec jugement
+CHUNK_SIZE = int(RATE * CHUNK_DURATION_MS / 1000)  # chunk to read
+CHUNK_BYTES = CHUNK_SIZE * 2  # 16bit = 2 bytes, PCM
+NUM_PADDING_CHUNKS = int(PADDING_DURATION_MS / CHUNK_DURATION_MS)
+# NUM_WINDOW_CHUNKS = int(240 / CHUNK_DURATION_MS)
+NUM_WINDOW_CHUNKS = int(400 / CHUNK_DURATION_MS)  # 400 ms/ 30ms  ge
+NUM_WINDOW_CHUNKS_END = NUM_WINDOW_CHUNKS * 2
+
+START_OFFSET = int(NUM_WINDOW_CHUNKS * CHUNK_DURATION_MS * 0.5 * RATE)
+
+vad = webrtcvad.Vad(1)
+
+pa = pyaudio.PyAudio()
+stream = pa.open(format=FORMAT,
+                 channels=CHANNELS,
+                 rate=RATE,
+                 input=True,
+                 start=False,
+                 # input_device_index=2,
+                 frames_per_buffer=CHUNK_SIZE)
+
+
+got_a_sentence = False
+leave = False
+
+
+def handle_int(sig, chunk):
+    global leave, got_a_sentence
+    leave = True
+    got_a_sentence = True
+
+
+def record_to_file(path, data, sample_width):
+    "Records from the microphone and outputs the resulting data to 'path'"
+    # sample_width, data = record()
+    data = pack('<' + ('h' * len(data)), *data)
+    wf = wave.open(path, 'wb')
+    wf.setnchannels(1)
+    wf.setsampwidth(sample_width)
+    wf.setframerate(RATE)
+    wf.writeframes(data)
+    wf.close()
+
+
+def normalize(snd_data):
+    "Average the volume out"
+    MAXIMUM = 32767  # 16384
+    times = float(MAXIMUM) / max(abs(i) for i in snd_data)
+    r = array('h')
+    for i in snd_data:
+        r.append(int(i * times))
+    return r
+
+signal.signal(signal.SIGINT, handle_int)
+
+while not leave:
+    ring_buffer = collections.deque(maxlen=NUM_PADDING_CHUNKS)
+    triggered = False
+    voiced_frames = []
+    ring_buffer_flags = [0] * NUM_WINDOW_CHUNKS
+    ring_buffer_index = 0
+
+    ring_buffer_flags_end = [0] * NUM_WINDOW_CHUNKS_END
+    ring_buffer_index_end = 0
+    buffer_in = ''
+    # WangS
+    raw_data = array('h')
+    index = 0
+    start_point = 0
+    StartTime = time.time()
+    print("* recording: ")
+    stream.start_stream()
+
+    while not got_a_sentence and not leave:
+        chunk = stream.read(CHUNK_SIZE)
+        # add WangS
+        raw_data.extend(array('h', chunk))
+        index += CHUNK_SIZE
+        TimeUse = time.time() - StartTime
+
+        active = vad.is_speech(chunk, RATE)
+
+        sys.stdout.write('1' if active else '_')
+        ring_buffer_flags[ring_buffer_index] = 1 if active else 0
+        ring_buffer_index += 1
+        ring_buffer_index %= NUM_WINDOW_CHUNKS
+
+        ring_buffer_flags_end[ring_buffer_index_end] = 1 if active else 0
+        ring_buffer_index_end += 1
+        ring_buffer_index_end %= NUM_WINDOW_CHUNKS_END
+
+        # start point detection
+        if not triggered:
+            ring_buffer.append(chunk)
+            num_voiced = sum(ring_buffer_flags)
+            if num_voiced > 0.8 * NUM_WINDOW_CHUNKS:
+                sys.stdout.write(' Open ')
+                triggered = True
+                start_point = index - CHUNK_SIZE * 20  # start point
+                # voiced_frames.extend(ring_buffer)
+                ring_buffer.clear()
+        # end point detection
+        else:
+            # voiced_frames.append(chunk)
+            ring_buffer.append(chunk)
+            num_unvoiced = NUM_WINDOW_CHUNKS_END - sum(ring_buffer_flags_end)
+            if num_unvoiced > 0.90 * NUM_WINDOW_CHUNKS_END or TimeUse > 10:
+                sys.stdout.write(' Close ')
+                triggered = False
+                got_a_sentence = True
+
+        sys.stdout.flush()
+
+    sys.stdout.write('\n')
+    # data = b''.join(voiced_frames)
+
+    stream.stop_stream()
+    print("* done recording")
+    got_a_sentence = False
+
+    # write to file
+    raw_data.reverse()
+    for index in range(start_point):
+        raw_data.pop()
+    raw_data.reverse()
+    raw_data = normalize(raw_data)
+    record_to_file("recording.wav", raw_data, 2)
+    leave = True
+
+stream.close()