Update changes for release

[Revisionist Note] This commit was originally c6a0c80, still available
on the main-pre-rewrite branch. The 0.10.0 tag used to point to it.

CHANGES.md

@@ -1,7 +1,3 @@
-# Version 0.10.1
-- restore previous xrun behaviour, #131
-- type hints
-
 # Version 0.10.0
 - assorted improvements (#123 from @ossilator)
   - support for `periods` in the `PCM` constructor.

alsaaudio.c

@@ -196,8 +196,8 @@ get_pcmtype(PyObject *obj)
 static bool is_value_volume_unit(long unit)
 {
 	if (unit == VOLUME_UNITS_PERCENTAGE ||
-		unit == VOLUME_UNITS_RAW ||
-		unit == VOLUME_UNITS_DB) {
+	    unit == VOLUME_UNITS_RAW ||
+	    unit == VOLUME_UNITS_DB) {
 		return true;
 	}
 	return false;
@@ -1423,6 +1423,8 @@ alsapcm_read(alsapcm_t *self, PyObject *args)
 
 static PyObject *alsapcm_write(alsapcm_t *self, PyObject *args)
 {
+	snd_pcm_state_t state;
+	int res;
 	int datalen;
 	char *data;
 	PyObject *rc = NULL;
@@ -1443,11 +1445,6 @@ static PyObject *alsapcm_write(alsapcm_t *self, PyObject *args)
 	if (!self->handle)
 	{
 		PyErr_SetString(ALSAAudioError, "PCM device is closed");
-
-#if PY_MAJOR_VERSION >= 3
-		PyBuffer_Release(&buf);
-#endif
-
 		return NULL;
 	}
 
@@ -1455,46 +1452,27 @@ static PyObject *alsapcm_write(alsapcm_t *self, PyObject *args)
 	{
 		PyErr_SetString(ALSAAudioError,
 						"Data size must be a multiple of framesize");
-
-#if PY_MAJOR_VERSION >= 3
-		PyBuffer_Release(&buf);
-#endif
 		return NULL;
 	}
 
-	int res;
-	snd_pcm_state_t state = snd_pcm_state(self->handle);
-
-
+	state = snd_pcm_state(self->handle);
 	if ((state != SND_PCM_STATE_XRUN && state != SND_PCM_STATE_SETUP) ||
 		(res = snd_pcm_prepare(self->handle)) >= 0) {
-
 		Py_BEGIN_ALLOW_THREADS
 		res = snd_pcm_writei(self->handle, data, datalen/self->framesize);
-		if (res == -EPIPE) {
-			/* EPIPE means underrun */
-			res = snd_pcm_recover(self->handle, res, 1);
-			if (res >= 0) {
-				res = snd_pcm_writei(self->handle, data, datalen/self->framesize);
-			}
-		}
 		Py_END_ALLOW_THREADS
 	}
 
 	if (res == -EAGAIN) {
 		rc = PyLong_FromLong(0);
 	}
-	res = snd_pcm_prepare(self->handle);
-	if (res < 0)
+	else if (res < 0)
 	{
 		PyErr_Format(ALSAAudioError, "%s [%s]", snd_strerror(res),
 					 self->cardname);
-
-#if PY_MAJOR_VERSION >= 3
-		PyBuffer_Release(&buf);
-#endif
-
-		return NULL;
+	}
+	else {
+		rc = PyLong_FromLong(res);
 	}
 
 #if PY_MAJOR_VERSION >= 3
@@ -1504,30 +1482,6 @@ static PyObject *alsapcm_write(alsapcm_t *self, PyObject *args)
 	return rc;
 }
 
-static PyObject *
-alsapcm_avail(alsapcm_t *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args,":avail"))
-		return NULL;
-
-	if (!self->handle)
-	{
-		PyErr_SetString(ALSAAudioError, "PCM device is closed");
-		return NULL;
-	}
-
-	long avail = snd_pcm_avail(self->handle);
-	// if (avail < 0)
-	// {
-	// 	PyErr_Format(ALSAAudioError, "%s [%s]", snd_strerror(avail),
-	// 				 self->cardname);
-
-	// 	return NULL;
-	// }
-
-	return PyLong_FromLong(avail);
-}
-
 static PyObject *alsapcm_pause(alsapcm_t *self, PyObject *args)
 {
 	int enabled=1, res;
@@ -1649,72 +1603,6 @@ alsapcm_polldescriptors(alsapcm_t *self, PyObject *args)
 	return result;
 }
 
-static PyObject *
-alsapcm_polldescriptors_revents(alsapcm_t *self, PyObject *args)
-{
-	PyObject *list_obj;
-
-	if (!PyArg_ParseTuple(args, "O!:polldescriptors_revents", &PyList_Type, &list_obj))
-	{
-		PyErr_SetString(PyExc_TypeError, "parameter must be a list.");
-		return NULL;
-	}
-
-	Py_ssize_t list_size = PyList_Size(list_obj);
-
-	struct pollfd *fds = (struct pollfd*)calloc(list_size, sizeof(struct pollfd));
-	if (!fds)
-	{
-		PyErr_Format(PyExc_MemoryError, "Out of memory [%s]",
-					 self->cardname);
-		return NULL;
-	}
-
-	for (int i = 0; i < list_size; i++)
-	{
-		PyObject *tuple_obj = PyList_GetItem(list_obj, i);
-		if(!PyTuple_Check(tuple_obj)) {
-			PyErr_SetString(PyExc_TypeError, "list items must be tuples.");
-			free(fds);
-			return NULL;
-		}
-
-		Py_ssize_t tuple_size = PyTuple_Size(tuple_obj);
-		if (tuple_size != 2) {
-			PyErr_SetString(PyExc_TypeError, "tuples inside list must be (fd: int, mask: int)");
-			free(fds);
-			return NULL;
-		}
-
-		PyObject* t0 = PyTuple_GetItem(tuple_obj, 0);
-		PyObject* t1 = PyTuple_GetItem(tuple_obj, 1);
-
-		if (!PyLong_Check(t0) || !PyLong_Check(t1)) {
-			PyErr_SetString(PyExc_TypeError, "tuples inside list must be (fd: int, mask: int)");
-			free(fds);
-			return NULL;
-		}
-
-		// leave fds[i].event as 0 (from calloc) for now
-		fds[i].fd = PyLong_AS_LONG(t0);
-		fds[i].revents = PyLong_AS_LONG(t1);
-	}
-
-	unsigned short revents;
-	int rc = snd_pcm_poll_descriptors_revents(self->handle, fds, (unsigned short)list_size, &revents);
-	if (rc < 0)
-	{
-		PyErr_Format(ALSAAudioError, "%s [%s]", snd_strerror(rc),
-					 self->cardname);
-		free(fds);
-		return NULL;
-	}
-
-	free(fds);
-
-	return PyLong_FromLong(revents);
-}
-
 /* ALSA PCM Object Bureaucracy */
 
 static PyMethodDef alsapcm_methods[] = {
@@ -1739,13 +1627,11 @@ static PyMethodDef alsapcm_methods[] = {
 	{"getchannels", (PyCFunction)alsapcm_getchannels, METH_VARARGS},
 	{"read", (PyCFunction)alsapcm_read, METH_VARARGS},
 	{"write", (PyCFunction)alsapcm_write, METH_VARARGS},
-	{"avail", (PyCFunction)alsapcm_avail, METH_VARARGS},
 	{"pause", (PyCFunction)alsapcm_pause, METH_VARARGS},
 	{"drop", (PyCFunction)alsapcm_drop, METH_VARARGS},
 	{"drain", (PyCFunction)alsapcm_drain, METH_VARARGS},
 	{"close", (PyCFunction)alsapcm_close, METH_VARARGS},
 	{"polldescriptors", (PyCFunction)alsapcm_polldescriptors, METH_VARARGS},
-	{"polldescriptors_revents", (PyCFunction)alsapcm_polldescriptors_revents, METH_VARARGS},
 	{NULL, NULL}
 };
 
@@ -2271,10 +2157,13 @@ alsamixer_getvolume(alsamixer_t *self, PyObject *args, PyObject *kwds)
 {
 	snd_mixer_elem_t *elem;
 	int channel;
+	long ival;
 	PyObject *pcmtypeobj = NULL;
 	long pcmtype;
 	int iunits = VOLUME_UNITS_PERCENTAGE;
-	PyObject *result = NULL;
+	PyObject *result;
+	PyObject *item;
+
 	char *kw[] = { "pcmtype", "units", NULL };
 
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:getvolume", kw, &pcmtypeobj, &iunits)) {
@@ -2298,9 +2187,6 @@ alsamixer_getvolume(alsamixer_t *self, PyObject *args, PyObject *kwds)
 	}
 	volume_units_t units = iunits;
 
-	// handle updates that may have occurred
-	snd_mixer_handle_events(self->handle);
-
 	elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid);
 
 	if (!pcmtypeobj || (pcmtypeobj == Py_None)) {
@@ -2315,8 +2201,6 @@ alsamixer_getvolume(alsamixer_t *self, PyObject *args, PyObject *kwds)
 	result = PyList_New(0);
 
 	for (channel = 0; channel <= SND_MIXER_SCHN_LAST; channel++) {
-		long ival;
-
 		if (pcmtype == SND_PCM_STREAM_PLAYBACK &&
 			snd_mixer_selem_has_playback_channel(elem, channel))
 		{
@@ -2334,7 +2218,7 @@ alsamixer_getvolume(alsamixer_t *self, PyObject *args, PyObject *kwds)
 				break;
 			}
 
-			PyObject* item = PyLong_FromLong(ival);
+			item = PyLong_FromLong(ival);
 			PyList_Append(result, item);
 			Py_DECREF(item);
 		}
@@ -2355,7 +2239,7 @@ alsamixer_getvolume(alsamixer_t *self, PyObject *args, PyObject *kwds)
 				break;
 			}
 
-			PyObject* item = PyLong_FromLong(ival);
+			item = PyLong_FromLong(ival);
 			PyList_Append(result, item);
 			Py_DECREF(item);
 		}

loopback.py

@@ -1,397 +0,0 @@
-#!/usr/bin/env python3
-# -*- mode: python; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*-
-
-import sys
-import select
-import logging
-import re
-import struct
-import subprocess
-from datetime import datetime, timedelta
-from alsaaudio import (PCM, pcms, PCM_PLAYBACK, PCM_CAPTURE, PCM_NONBLOCK, Mixer,
-	PCM_STATE_OPEN, PCM_STATE_SETUP, PCM_STATE_PREPARED, PCM_STATE_RUNNING, PCM_STATE_XRUN, PCM_STATE_DRAINING,
-	PCM_STATE_PAUSED, PCM_STATE_SUSPENDED, ALSAAudioError)
-from argparse import ArgumentParser
-
-poll_names = {
-	select.POLLIN: 'POLLIN',
-	select.POLLPRI: 'POLLPRI',
-	select.POLLOUT: 'POLLOUT',
-	select.POLLERR: 'POLLERR',
-	select.POLLHUP: 'POLLHUP',
-	select.POLLRDHUP: 'POLLRDHUP',
-	select.POLLNVAL: 'POLLNVAL'
-}
-
-state_names = {
-	PCM_STATE_OPEN: 'PCM_STATE_OPEN',
-	PCM_STATE_SETUP: 'PCM_STATE_SETUP',
-	PCM_STATE_PREPARED: 'PCM_STATE_PREPARED',
-	PCM_STATE_RUNNING: 'PCM_STATE_RUNNING',
-	PCM_STATE_XRUN: 'PCM_STATE_XRUN',
-	PCM_STATE_DRAINING: 'PCM_STATE_DRAINING',
-	PCM_STATE_PAUSED: 'PCM_STATE_PAUSED',
-	PCM_STATE_SUSPENDED: 'PCM_STATE_SUSPENDED'
-}
-
-def poll_desc(mask):
-	return '|'.join([poll_names[bit] for bit, name in poll_names.items() if mask & bit])
-
-class PollDescriptor(object):
-	'''File Descriptor, event mask and a name for logging'''
-	def __init__(self, name, fd, mask):
-		self.name = name
-		self.fd = fd
-		self.mask = mask
-
-	def as_tuple(self):
-		return (self.fd, self.mask)
-
-	@classmethod
-	def from_alsa_object(cls, name, alsaobject, mask=None):
-		# TODO maybe refactor: we ignore objects that have more then one polldescriptor
-		fd, alsamask = alsaobject.polldescriptors()[0]
-
-		if mask is None:
-			mask = alsamask
-
-		return cls(name, fd, mask)
-
-class Loopback(object):
-	'''Loopback state and event handling'''
-
-	def __init__(self, capture, playback_args, volume_handler, run_after_stop=None, run_before_start=None):
-		self.playback_args = playback_args
-		self.playback = None
-		self.volume_handler = volume_handler
-		self.capture_started = None
-		self.last_capture_event = None
-
-		self.capture = capture
-		self.capture_pd = PollDescriptor.from_alsa_object('capture', capture)
-
-		self.run_after_stop = run_after_stop.split(' ')
-		self.run_before_start = run_before_start.split(' ')
-		self.run_after_stop_did_run = False
-
-		self.waitBeforeOpen = False
-		self.queue = []
-
-		self.period_size = 0
-		self.silent_periods = 0
-
-	@staticmethod
-	def compute_energy(data):
-		values = struct.unpack(f'{len(data)//2}h', data)
-		e = 0
-		for v in values:
-			e = e + v * v
-
-		return e
-
-	@staticmethod
-	def run_command(cmd):
-		if cmd:
-			rc = subprocess.run(cmd)
-			if rc.returncode:
-				logging.warning(f'run {cmd}, return code {rc.returncode}')
-			else:
-				logging.info(f'run {cmd}, return code {rc.returncode}')
-
-	def register(self, reactor):
-		reactor.register_timeout_handler(self.timeout_handler)
-		reactor.register(self.capture_pd, self)
-
-	def start(self):
-		# start reading data
-		size, data = self.capture.read()
-		if size:
-			self.queue.append(data)
-
-	def timeout_handler(self):
-		if self.playback and self.capture_started:
-			if self.last_capture_event:
-				if datetime.now() - self.last_capture_event > timedelta(seconds=2):
-					logging.info('timeout - closing playback device')
-					self.playback.close()
-					self.playback = None
-					self.capture_started = None
-					if self.volume_handler:
-						self.volume_handler.stop()
-					self.run_command(self.run_after_stop)
-			return
-
-		self.waitBeforeOpen = False
-
-		if not self.run_after_stop_did_run and not self.playback:
-			if self.volume_handler:
-				self.volume_handler.stop()
-			self.run_command(self.run_after_stop)
-			self.run_after_stop_did_run = True
-
-	def pop(self):
-		if len(self.queue):
-			return self.queue.pop()
-		else:
-			return None
-
-	def handle_capture_event(self, eventmask, name):
-		'''called when data is available for reading'''
-		self.last_capture_event = datetime.now()
-		size, data = self.capture.read()
-		if not size:
-			logging.warning(f'capture event but no data')
-			return False
-
-		energy = self.compute_energy(data)
-		logging.debug(f'energy: {energy}')
-
-		# the usecase is a USB capture device where we get perfect silence when it's idle
-		if energy == 0:
-			self.silent_periods = self.silent_periods + 1
-
-			# turn off playback after two seconds of silence
-			# 2 channels * 2 seconds * 2 bytes per sample
-			fps = self.playback_args['rate']  * 8 // (self.playback_args['periodsize'] * self.playback_args['periods'])
-
-			logging.debug(f'{self.silent_periods} of {fps} silent periods: {self.playback}')
-
-			if self.silent_periods > fps and self.playback:
-				logging.info(f'closing playback due to silence')
-				self.playback.close()
-				self.playback = None
-				if self.volume_handler:
-					self.volume_handler.stop()
-				self.run_command(self.run_after_stop)
-				self.run_after_stop_did_run = True
-
-			if not self.playback:
-				return
-		else:
-			self.silent_periods = 0
-
-		if not self.playback:
-			if self.waitBeforeOpen:
-				return False
-			try:
-				if self.volume_handler:
-					self.volume_handler.start()
-				self.run_command(self.run_before_start)
-				self.playback = PCM(**self.playback_args)
-				self.period_size = self.playback.info()['period_size']
-				logging.info(f'opened playback device with period_size {self.period_size}')
-			except ALSAAudioError as e:
-				logging.info('opening PCM playback device failed: %s', e)
-				self.waitBeforeOpen = True
-				return False
-
-			self.capture_started = datetime.now()
-			logging.info(f'{self.playback} capture started: {self.capture_started}')
-
-		self.queue.append(data)
-
-		if len(self.queue) <= 2:
-			logging.info(f'buffering: {len(self.queue)}')
-			return False
-
-		try:
-			data = self.pop()
-			if data:
-				space = self.playback.avail()
-				written = self.playback.write(data)
-				logging.debug(f'wrote {written} bytes while space was {space}')
-		except ALSAAudioError:
-			logging.error('underrun', exc_info=1)
-
-		return True
-
-	def __call__(self, fd, eventmask, name):
-
-		if fd == self.capture_pd.fd:
-			real_mask = self.capture.polldescriptors_revents([self.capture_pd.as_tuple()])
-			if real_mask:
-				return self.handle_capture_event(real_mask, name)
-			else:
-				logging.debug('null capture event')
-				return False
-		else:
-			real_mask = self.playback.polldescriptors_revents([self.playback_pd.as_tuple()])
-			if real_mask:
-				return self.handle_playback_event(real_mask, name)
-			else:
-				logging.debug('null playback event')
-				return False
-
-class VolumeForwarder(object):
-	'''Volume control event handling'''
-
-	def __init__(self, capture_control, playback_control):
-		self.playback_control = playback_control
-		self.capture_control = capture_control
-		self.active = True
-
-	def start(self):
-		self.active = True
-		if self.volume:
-			self.volume = playback_control.setvolume(self.volume)
-
-	def stop(self):
-		self.active = False
-		self.volume = self.playback_control.getvolume(pcmtype=PCM_CAPTURE)[0]
-
-	def __call__(self, fd, eventmask, name):
-		if not self.active:
-			return
-
-		volume = self.capture_control.getvolume(pcmtype=PCM_CAPTURE)
-		# indicate that we've handled the event
-		self.capture_control.handleevents()
-		logging.info(f'{name} adjusting volume to {volume}')
-		if volume:
-			self.playback_control.setvolume(volume[0])
-
-
-class Reactor(object):
-	'''A wrapper around select.poll'''
-
-	def __init__(self):
-		self.poll = select.poll()
-		self.descriptors = {}
-		self.timeout_handlers = set()
-
-	def register(self, polldescriptor, callable):
-		logging.debug(f'registered {polldescriptor.name}: {poll_desc(polldescriptor.mask)}')
-		self.descriptors[polldescriptor.fd] = (polldescriptor, callable)
-		self.poll.register(polldescriptor.fd, polldescriptor.mask)
-
-	def unregister(self, polldescriptor):
-		self.poll.unregister(polldescriptor.fd)
-		del self.descriptors[polldescriptor.fd]
-
-	def register_timeout_handler(self, callable):
-		self.timeout_handlers.add(callable)
-
-	def unregister_timeout_handler(self, callable):
-		self.timeout_handlers.remove(callable)
-
-	def run(self):
-		last_timeout_ev = datetime.now()
-		while True:
-			# poll for a bit, then send a timeout to registered handlers
-			events = self.poll.poll(0.25)
-			for fd, ev in events:
-				polldescriptor, handler = self.descriptors[fd]
-
-				# very chatty - log all events
-				# logging.debug(f'{polldescriptor.name}: {poll_desc(ev)} ({ev})')
-
-				handler(fd, ev, polldescriptor.name)
-
-			if datetime.now() - last_timeout_ev > timedelta(seconds=0.25):
-				for t in self.timeout_handlers:
-					t()
-				last_timeout_ev = datetime.now()
-
-
-if __name__ == '__main__':
-
-	logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
-
-	parser = ArgumentParser(description='ALSA loopback (with volume forwarding)')
-
-	playback_pcms = pcms(pcmtype=PCM_PLAYBACK)
-	capture_pcms = pcms(pcmtype=PCM_CAPTURE)
-
-	if not playback_pcms:
-		logging.error('no playback PCM found')
-		sys.exit(2)
-
-	if not capture_pcms:
-		logging.error('no capture PCM found')
-		sys.exit(2)
-
-	parser.add_argument('-d', '--debug', action='store_true')
-	parser.add_argument('-i', '--input', default=capture_pcms[0])
-	parser.add_argument('-o', '--output', default=playback_pcms[0])
-	parser.add_argument('-r', '--rate', type=int, default=44100)
-	parser.add_argument('-c', '--channels', type=int, default=2)
-	parser.add_argument('-p', '--periodsize', type=int, default=444) # must be divisible by 6 for 44k1
-	parser.add_argument('-P', '--periods', type=int, default=2)
-	parser.add_argument('-I', '--input-mixer', help='Control of the input mixer, can contain the card index, e.g. Digital:2')
-	parser.add_argument('-O', '--output-mixer', help='Control of the output mixer, can contain the card index, e.g. PCM:1')
-	parser.add_argument('-A', '--run-after-stop', help='command to run when the capture device is idle/silent')
-	parser.add_argument('-B', '--run-before-start', help='command to run when the capture device becomes active')
-	parser.add_argument('-V', '--volume', help='Initial volume (default is leave unchanged)')
-
-	args = parser.parse_args()
-
-	if args.debug:
-		logging.getLogger().setLevel(logging.DEBUG)
-
-	playback_args = {
-		'type': PCM_PLAYBACK,
-		'mode': PCM_NONBLOCK,
-		'device': args.output,
-		'rate': args.rate,
-		'channels': args.channels,
-		'periodsize': args.periodsize,
-		'periods': args.periods
-	}
-
-	reactor = Reactor()
-
-	# If args.input_mixer and args.output_mixer are set, forward the capture volume to the playback volume.
-	# The usecase is a capture device that is implemented using g_audio, i.e. the Linux USB gadget driver.
-	# When a USB device (eg. an iPad) is connected to this machine, its volume events will go to the volume control
-	# of the output device
-
-	capture = None
-	playback = None
-	volume_handler = None
-	if args.input_mixer and args.output_mixer:
-		re_mixer = re.compile(r'([a-zA-Z0-9]+):?([0-9+])?')
-
-		input_mixer_card = None
-		m = re_mixer.match(args.input_mixer)
-		if m:
-			input_mixer = m.group(1)
-			if m.group(2):
-				input_mixer_card = int(m.group(2))
-		else:
-			parser.print_usage()
-			sys.exit(1)
-
-		output_mixer_card = None
-		m = re_mixer.match(args.output_mixer)
-		if m:
-			output_mixer = m.group(1)
-			if m.group(2):
-				output_mixer_card = int(m.group(2))
-		else:
-			parser.print_usage()
-			sys.exit(1)
-
-		if input_mixer_card is None:
-			capture = PCM(type=PCM_CAPTURE, mode=PCM_NONBLOCK, device=args.input, rate=args.rate,
-				channels=args.channels, periodsize=args.periodsize, periods=args.periods)
-			input_mixer_card = capture.info()['card_no']
-
-		if output_mixer_card is None:
-			playback = PCM(**playback_args)
-			output_mixer_card = playback.info()['card_no']
-			playback.close()
-
-		playback_control = Mixer(control=output_mixer, cardindex=int(output_mixer_card))
-		capture_control = Mixer(control=input_mixer, cardindex=int(input_mixer_card))
-
-		volume_handler = VolumeForwarder(capture_control, playback_control)
-		reactor.register(PollDescriptor.from_alsa_object('capture_control', capture_control, select.POLLIN), volume_handler)
-
-	if args.volume and playback_control:
-		playback_control.setvolume(int(args.volume))
-
-	loopback = Loopback(capture, playback_args, volume_handler, args.run_after_stop, args.run_before_start)
-	loopback.register(reactor)
-	loopback.start()
-
-	reactor.run()

mixertest.py

@@ -72,13 +72,8 @@ def show_mixer(name, kwargs):
     volumes = mixer.getvolume()
     volumes_dB = mixer.getvolume(units=alsaaudio.VOLUME_UNITS_DB)
     for i in range(len(volumes)):
-        print("Channel %i playback volume: %i%% (%.1f dB)" % (i, volumes[i], volumes_dB[i] / 100.0))
-
-    volumes = mixer.getvolume(pcmtype=alsaaudio.PCM_CAPTURE)
-    volumes_dB = mixer.getvolume(pcmtype=alsaaudio.PCM_CAPTURE, units=alsaaudio.VOLUME_UNITS_DB)
-    for i in range(len(volumes)):
-        print("Channel %i capture volume: %i%% (%.1f dB)" % (i, volumes[i], volumes_dB[i] / 100.0))
-
+        print("Channel %i volume: %i%% (%.1f dB)" % (i, volumes[i], volumes_dB[i] / 100.0))
+        
     try:
         mutes = mixer.getmute()
         for i in range(len(mutes)):
@@ -118,7 +113,7 @@ def set_mixer(name, args, kwargs):
             mixer.setmute(1, channel)
         else:
             mixer.setmute(0, channel)
-
+        
     elif args in ['rec','unrec']:
         # Enable/disable recording
         if args == 'rec':

setup.py

@@ -8,7 +8,7 @@ from setuptools import setup
 from setuptools.extension import Extension
 from sys import version
 
-pyalsa_version = '0.10.1'
+pyalsa_version = '0.10.0'
 
 if __name__ == '__main__':
     setup(
@@ -29,12 +29,12 @@ if __name__ == '__main__':
             'License :: OSI Approved :: Python Software Foundation License',
             'Operating System :: POSIX :: Linux',
             'Programming Language :: Python :: 2',
-            'Programming Language :: Python :: 3',
+            'Programming Language :: Python :: 3',    
             'Topic :: Multimedia :: Sound/Audio',
             'Topic :: Multimedia :: Sound/Audio :: Mixers',
             'Topic :: Multimedia :: Sound/Audio :: Players',
             'Topic :: Multimedia :: Sound/Audio :: Capture/Recording',
             ],
-        ext_modules=[Extension('alsaaudio',['alsaaudio.c'],
+        ext_modules=[Extension('alsaaudio',['alsaaudio.c'], 
                                libraries=['asound'])]
     )

test.py

@@ -11,7 +11,6 @@
 import unittest
 import alsaaudio
 import warnings
-from contextlib import closing
 
 # we can't test read and write well - these are tested otherwise
 PCMMethods = [
@@ -21,7 +20,7 @@ PCMMethods = [
 ]
 
 PCMDeprecatedMethods = [
-	('setchannels', (2,)),
+	('setchannels', (2,)), 
 	('setrate', (44100,)),
 	('setformat', (alsaaudio.PCM_FORMAT_S8,)),
 	('setperiodsize', (320,))
@@ -50,10 +49,10 @@ class MixerTest(unittest.TestCase):
 
 	def testMixer(self):
 		"""Open the default Mixers and the Mixers on every card"""
-
+		
 		for c in alsaaudio.card_indexes():
 			mixers = alsaaudio.mixers(cardindex=c)
-
+			
 			for m in mixers:
 				mixer = alsaaudio.Mixer(m, cardindex=c)
 				mixer.close()
@@ -74,7 +73,7 @@ class MixerTest(unittest.TestCase):
 		mixer.close()
 
 	def testMixerClose(self):
-		"""Run common Mixer methods on a closed object and verify it raises an
+		"""Run common Mixer methods on a closed object and verify it raises an 
 		error"""
 
 		mixers = alsaaudio.mixers()
@@ -134,7 +133,7 @@ class PCMTest(unittest.TestCase):
 				pcm = alsaaudio.PCM(card='default')
 			except alsaaudio.ALSAAudioError:
 				pass
-
+				
 			# Verify we got a DepreciationWarning
 			self.assertEqual(len(w), 1, "PCM(card='default') expected a warning" )
 			self.assertTrue(issubclass(w[-1].category, DeprecationWarning), "PCM(card='default') expected a DeprecationWarning")
@@ -157,31 +156,5 @@ class PCMTest(unittest.TestCase):
 				self.assertEqual(len(w), 1, method + " expected a warning")
 				self.assertTrue(issubclass(w[-1].category, DeprecationWarning), method + " expected a DeprecationWarning")
 
-class PollDescriptorArgsTest(unittest.TestCase):
-	'''Test invalid args for polldescriptors_revents (takes a list of tuples of 2 integers)'''
-	def testArgsNoList(self):
-		with closing(alsaaudio.PCM()) as pcm:
-			with self.assertRaises(TypeError):
-				pcm.polldescriptors_revents('foo')
-
-	def testArgsListButNoTuples(self):
-		with closing(alsaaudio.PCM()) as pcm:
-			with self.assertRaises(TypeError):
-				pcm.polldescriptors_revents(['foo', 1])
-
-	def testArgsListButInvalidTuples(self):
-		with closing(alsaaudio.PCM()) as pcm:
-			with self.assertRaises(TypeError):
-				pcm.polldescriptors_revents([('foo', 'bar')])
-
-	def testArgsListTupleWrongLength(self):
-		with closing(alsaaudio.PCM()) as pcm:
-			with self.assertRaises(TypeError):
-				pcm.polldescriptors_revents([(1, )])
-
-			with self.assertRaises(TypeError):
-				pcm.polldescriptors_revents([(1, 2, 3)])
-
-
 if __name__ == '__main__':
 	unittest.main()