Merge branch 'dev' into master

Author: renekliment

.travis.yml

@@ -18,7 +18,7 @@ sudo: required
 # Some discussion: https://github.com/koalaman/shellcheck/issues/785
 before_install:
   - sudo apt-get update
-  - sudo apt-get install -y wget git swig libasound2-dev libpulse-dev vlc-nox shellcheck
+  - sudo apt-get install -y wget git swig portaudio19-dev libpulse-dev vlc-nox shellcheck
 
 install:
   - pip install -r src/requirements.txt

CHANGELOG.md

@@ -5,6 +5,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [Unreleased]
 
+### Added
+- Windows support
+
+### Changed
+- Switched from pyalsaaudio (ALSA) to pyaudio (PortAudio)
+    - You might have to change the `input_device` in your config, but this name will stay forever (we are not planning any change).
+    - Also removed config option to allow unlisted devices as this is not possible from now on (you have to select a device from the list).
+
 ## [1.5.1] - 2017-10-08
 Small bugfix release.
 

README.md

@@ -1,6 +1,6 @@
 # AlexaPi (the new & awesome version) [![Gitter chat](https://badges.gitter.im/alexa-pi/Lobby.png)](https://gitter.im/alexa-pi/Lobby)
 
-This is a client for Amazon's Alexa service. It is intended and tested to run on a wide range of platforms, such as Raspberry Pi, Orange Pi, CHIP and ordinary Linux desktops.
+This is a client for Amazon's Alexa service. It is intended and tested to run on a wide range of platforms, such as Raspberry Pi, Orange Pi, CHIP and ordinary Linux or Windows desktops.
 
 ### Do you want to help out? Read the [Contribution Guide](CONTRIBUTING.md).
 
@@ -10,16 +10,16 @@ This is a client for Amazon's Alexa service. It is intended and tested to run on
 
 You will need:
 
-1. **A Linux box**
+1. **A Linux or Windows box**
     - a Raspberry Pi and an SD Card with a fresh install of Raspbian
     - or an Orange Pi with Armbian
-    - or pretty much any up-to-date Linux system
+    - or pretty much any up-to-date Linux/Windows system
 2. **Audio peripherals**
     - external speaker with 3.5mm Jack
     - USB Sound Dongle and microphone
-3. Other
-    - (optional) (Raspberry Pi) a push button connected between GPIO 18 and GND (configurable)
-    - (optional) (Raspberry Pi) a dual colour LED (or 2 single LEDs) connected to GPIO 24 & 25 (configurable)
+3. **Optional (only for Raspberry Pi)**
+    - a push button connected between GPIO 18 and GND (configurable)
+    - a dual colour LED (or 2 single LEDs) connected between GPIO 24 & 25 and GND (configurable)
 
 ## You wanna give it a try? Check out the [Installation Guide](https://github.com/alexa-pi/AlexaPi/wiki/Installation).
 

pylintrc

@@ -21,7 +21,7 @@ load-plugins=
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code
-extension-pkg-whitelist=alsaaudio,pyA20,CHIP_IO
+extension-pkg-whitelist=pyA20,CHIP_IO
 
 [MESSAGES CONTROL]
 
@@ -158,7 +158,7 @@ notes=XXX
 [SIMILARITIES]
 
 # Minimum lines number of a similarity.
-min-similarity-lines=4
+min-similarity-lines=5
 
 # Ignore comments when computing similarities.
 ignore-comments=yes

src/alexapi/capture.py

@@ -1,14 +1,46 @@
 import logging
 import time
+import threading
+import os
+import queue
 
-import alsaaudio
 import webrtcvad
 
 from .exceptions import ConfigurationException
 
+os.environ["PA_ALSA_PLUGHW"] = "1"
+import pyaudio # pylint: disable=wrong-import-position,wrong-import-order
+
+
 logger = logging.getLogger(__name__)
 
 
+class DeviceInfo(object):
+
+	_pa = None
+
+	def __init__(self):
+		self._pa = pyaudio.PyAudio()
+
+	def get_device_list(self, input_only=False):
+
+		device_list = []
+		for i in range(self._pa.get_device_count()):
+			if (not input_only) or (input_only and self._pa.get_device_info_by_index(i)['maxInputChannels'] > 0):
+				device_list.append(self._pa.get_device_info_by_index(i)['name'])
+
+		return device_list
+
+	def get_device_index(self, name):
+		if not name:
+			return None
+
+		return self.get_device_list().index(name)
+
+	def __del__(self):
+		self._pa.terminate()
+
+
 class Capture(object):
 
 	MAX_RECORDING_LENGTH = 8
@@ -19,22 +51,41 @@ class Capture(object):
 	VAD_SILENCE_TIMEOUT = 1000
 	VAD_THROWAWAY_FRAMES = 10
 
+	_pa = None
+	_pa_exception_on_overflow = False
+
+	_handle = None
+	_handle_chunk_size = None
+
+	_device_info = None
+	_stream = None
+	_callback_data = None
+	_queue = None
 	_vad = None
 	_config = None
 	_tmp_path = None
 	_state_callback = None
+	_interrupt = False
+	_recording_lock_inverted = None
 
 	def __init__(self, config, tmp_path):
 		self._config = config
 		self._tmp_path = tmp_path
 
+		self._pa = pyaudio.PyAudio()
+		self._queue = queue.Queue()
+		self._device_info = DeviceInfo()
+
+		self._recording_lock_inverted = threading.Event()
+		self._recording_lock_inverted.set()
+
 		self.validate_config()
 
 	def validate_config(self):
 		input_device = self._config['sound']['input_device']
-		input_devices = alsaaudio.pcms(alsaaudio.PCM_CAPTURE)
+		input_devices = self._device_info.get_device_list(True)
 
-		if (input_device not in input_devices) and (not self._config['sound']['allow_unlisted_input_device']):
+		if input_device and (input_device not in input_devices):
 			raise ConfigurationException(
 				"Your input_device '" + input_device + "' is invalid. Use one of the following:\n"
 				+ '\n'.join(input_devices))
@@ -43,88 +94,141 @@ def setup(self, state_callback):
 		self._vad = webrtcvad.Vad(2)
 		self._state_callback = state_callback
 
-	def silence_listener(self, throwaway_frames=None, force_record=None):
+	def cleanup(self):
 
-		throwaway_frames = throwaway_frames or self.VAD_THROWAWAY_FRAMES
+		if not self._recording_lock_inverted.isSet():
+			self._interrupt = True
+			self._recording_lock_inverted.wait()
 
-		logger.debug("Setting up recording")
+		self._pa.terminate()
 
-		# Reenable reading microphone raw data
-		inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, self._config['sound']['input_device'])
-		inp.setchannels(1)
-		inp.setrate(self.VAD_SAMPLERATE)
-		inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
-		inp.setperiodsize(self.VAD_PERIOD)
+	def handle_init(self, rate, chunk_size):
 
-		debug = logging.getLogger('alexapi').getEffectiveLevel() == logging.DEBUG
+		self._handle = self._pa.open(
+			input=True,
+			input_device_index=self._device_info.get_device_index(self._config['sound']['input_device']),
+			format=pyaudio.paInt16,
+			channels=1,
+			rate=rate,
+			frames_per_buffer=chunk_size
+		)
 
-		logger.debug("Start recording")
+		self._handle_chunk_size = chunk_size
 
-		if self._state_callback:
-			self._state_callback()
+	def handle_read(self):
+		return self._handle.read(self._handle_chunk_size, exception_on_overflow=self._pa_exception_on_overflow)
 
-		def _listen():
-			start = time.time()
+	def handle_release(self):
+		self._handle.close()
 
-			do_VAD = True
-			if force_record and not force_record[1]:
-				do_VAD = False
+	def _callback(self, in_data, frame_count, time_info, status):  # pylint: disable=unused-argument
 
-			# Buffer as long as we haven't heard enough silence or the total size is within max size
-			thresholdSilenceMet = False
-			frames = 0
-			numSilenceRuns = 0
-			silenceRun = 0
+		debug = logging.getLogger('alexapi').getEffectiveLevel() == logging.DEBUG
 
-			if debug:
-				audio = b''
+		if not in_data:
+			self._queue.put(False)
+			return None, pyaudio.paAbort
+
+		do_VAD = True
+		if self._callback_data['force_record'] and not self._callback_data['force_record'][1]:
+			do_VAD = False
+
+		# do not count first 10 frames when doing VAD
+		if do_VAD and (self._callback_data['frames'] < self._callback_data['throwaway_frames']):
+			self._callback_data['frames'] += 1
+
+		# now do VAD
+		elif (self._callback_data['force_record'] and self._callback_data['force_record'][0]()) \
+				or (do_VAD and (self._callback_data['thresholdSilenceMet'] is False)
+					and ((time.time() - self._callback_data['start']) < self.MAX_RECORDING_LENGTH)):
 
 			if do_VAD:
-				# do not count first 10 frames when doing VAD
-				while frames < throwaway_frames:
-					length, data = inp.read()
-					frames += 1
-					if length:
-						yield data
-
-						if debug:
-							audio += data
-
-			# now do VAD
-			while (force_record and force_record[0]()) \
-					or (do_VAD and (thresholdSilenceMet is False) and ((time.time() - start) < self.MAX_RECORDING_LENGTH)):
-
-				length, data = inp.read()
-				if length:
-					yield data
 
-					if debug:
-						audio += data
+				if int(len(in_data) / 2) == self.VAD_PERIOD:
+					isSpeech = self._vad.is_speech(in_data, self.VAD_SAMPLERATE)
+
+					if not isSpeech:
+						self._callback_data['silenceRun'] += 1
+					else:
+						self._callback_data['silenceRun'] = 0
+						self._callback_data['numSilenceRuns'] += 1
 
-					if do_VAD and (length == self.VAD_PERIOD):
-						isSpeech = self._vad.is_speech(data, self.VAD_SAMPLERATE)
+				# only count silence runs after the first one
+				# (allow user to speak for total of max recording length if they haven't said anything yet)
+				if (self._callback_data['numSilenceRuns'] != 0) \
+						and ((self._callback_data['silenceRun'] * self.VAD_FRAME_MS) > self.VAD_SILENCE_TIMEOUT):
+					self._callback_data['thresholdSilenceMet'] = True
 
-						if not isSpeech:
-							silenceRun += 1
-						else:
-							silenceRun = 0
-							numSilenceRuns += 1
+		else:
+			self._queue.put(False)
+			return None, pyaudio.paComplete
 
-				if do_VAD:
-					# only count silence runs after the first one
-					# (allow user to speak for total of max recording length if they haven't said anything yet)
-					if (numSilenceRuns != 0) and ((silenceRun * self.VAD_FRAME_MS) > self.VAD_SILENCE_TIMEOUT):
-						thresholdSilenceMet = True
+		self._queue.put(in_data)
+		if debug:
+			self._callback_data['audio'] += in_data
 
-			logger.debug("End recording")
+		return None, pyaudio.paContinue
 
-			inp.close()
+	def silence_listener(self, throwaway_frames=None, force_record=None):
+
+		logger.debug("Recording: Setting up")
+
+		self._recording_lock_inverted.clear()
+
+		debug = logging.getLogger('alexapi').getEffectiveLevel() == logging.DEBUG
+
+		if self._state_callback:
+			self._state_callback()
+
+		self._queue.queue.clear()
+
+		self._callback_data = {
+			'start': time.time(),
+			'thresholdSilenceMet': False,  # Buffer as long as we haven't heard enough silence or the total size is within max size
+			'frames': 0,
+			'throwaway_frames': throwaway_frames or self.VAD_THROWAWAY_FRAMES,
+			'numSilenceRuns': 0,
+			'silenceRun': 0,
+			'force_record': force_record,
+			'audio': b'' if debug else False,
+		}
+
+		stream = self._pa.open(
+			input=True,
+			input_device_index=self._device_info.get_device_index(self._config['sound']['input_device']),
+			format=pyaudio.paInt16,
+			channels=1,
+			rate=self.VAD_SAMPLERATE,
+			frames_per_buffer=self.VAD_PERIOD,
+			stream_callback=self._callback,
+			start=False
+		)
+
+		logger.debug("Recording: Start")
+		stream.start_stream()
+
+		def _listen():
+			while True:
+				try:
+					data = self._queue.get(block=True, timeout=2)
+					if not data or self._interrupt:
+						break
+
+					yield data
+				except queue.Empty:
+					break
+
+			stream.stop_stream()
+			logger.debug("Recording: End")
+			stream.close()
 
 			if self._state_callback:
 				self._state_callback(False)
 
 			if debug:
 				with open(self._tmp_path + 'recording.wav', 'wb') as rf:
-					rf.write(audio)
+					rf.write(self._callback_data['audio'])
+
+			self._recording_lock_inverted.set()
 
 		return _listen()