alsaaudio

The alsaaudio module defines functions and classes for using ALSA.

alsaaudio.pcms(pcmtype: int = PCM_PLAYBACK) → list[str]

List available PCM devices by name.

Arguments are:

• pcmtype - can be either PCM_CAPTURE or PCM_PLAYBACK (default).

Note:

For PCM_PLAYBACK, the list of device names should be equivalent to the list of device names that aplay -L displays on the commandline:

$ aplay -L

For PCM_CAPTURE, the list of device names should be equivalent to the list of device names that arecord -L displays on the commandline:

$ arecord -L

New in 0.8

alsaaudio.cards() → list[str]

List the available ALSA cards by name. This function is only moderately useful. If you want to see a list of available PCM devices, use pcms() instead.

alsaaudio.mixers(cardindex: int = -1, device: str = 'default') → list[str]

List the available mixers. The arguments are:

• cardindex - the card index. If this argument is given, the device name is constructed as: ‘hw:cardindex’ and the device keyword argument is ignored. 0 is the first hardware sound card.

  Note: This should not be used, as it bypasses most of ALSA’s configuration.

• device - the name of the device on which the mixer resides. The default is 'default'.

Note: For a list of available controls, you can also use amixer on the commandline:

$ amixer

To elaborate the example, calling mixers() with the argument cardindex=0 should give the same list of Mixer controls as:

$ amixer -c 0

And calling mixers() with the argument device='foo' should give the same list of Mixer controls as:

$ amixer -D foo

Changed in 0.8:

• The keyword argument device is new and can be used to select virtual devices. As a result, the default behaviour has subtly changed. Since 0.8, this functions returns the mixers for the default device, not the mixers for the first card.

alsaaudio.asoundlib_version() → str

Return a Python string containing the ALSA version found.

PCM Objects

PCM objects in alsaaudio can play or capture (record) PCM sound through speakers or a microphone. The PCM constructor takes the following arguments:

PCM(type: int = PCM_PLAYBACK, mode: int = PCM_NORMAL, rate: int = 44100, channels: int = 2,

format: int = PCM_FORMAT_S16_LE, periodsize: int = 32, periods: int = 4,

device: str = 'default', cardindex: int = -1) -> PCM

This class is used to represent a PCM device (either for playback or recording). The constructor’s arguments are:

• type - can be either PCM_CAPTURE or PCM_PLAYBACK (default).

• mode - can be either PCM_NONBLOCK, or PCM_NORMAL (default).

• rate - the sampling rate in Hz. Typical values are 8000 (mainly used for telephony), 16000, 44100 (default), 48000 and 96000.

• channels - the number of channels. The default value is 2 (stereo).

• format - the data format. This controls how the PCM device interprets data for playback, and how data is encoded in captures. The default value is PCM_FORMAT_S16_LE.

Format	Description
PCM_FORMAT_S8	Signed 8 bit samples for each channel
PCM_FORMAT_U8	Unsigned 8 bit samples for each channel
PCM_FORMAT_S16_LE	Signed 16 bit samples for each channel Little Endian byte order)
PCM_FORMAT_S16_BE	Signed 16 bit samples for each channel (Big Endian byte order)
PCM_FORMAT_U16_LE	Unsigned 16 bit samples for each channel (Little Endian byte order)
PCM_FORMAT_U16_BE	Unsigned 16 bit samples for each channel (Big Endian byte order)
PCM_FORMAT_S24_LE	Signed 24 bit samples for each channel (Little Endian byte order in 4 bytes)
PCM_FORMAT_S24_BE	Signed 24 bit samples for each channel (Big Endian byte order in 4 bytes)
PCM_FORMAT_U24_LE	Unsigned 24 bit samples for each channel (Little Endian byte order in 4 bytes)
PCM_FORMAT_U24_BE	Unsigned 24 bit samples for each channel (Big Endian byte order in 4 bytes)
PCM_FORMAT_S32_LE	Signed 32 bit samples for each channel (Little Endian byte order)
PCM_FORMAT_S32_BE	Signed 32 bit samples for each channel (Big Endian byte order)
PCM_FORMAT_U32_LE	Unsigned 32 bit samples for each channel (Little Endian byte order)
PCM_FORMAT_U32_BE	Unsigned 32 bit samples for each channel (Big Endian byte order)
PCM_FORMAT_FLOAT_LE	32 bit samples encoded as float (Little Endian byte order)
PCM_FORMAT_FLOAT_BE	32 bit samples encoded as float (Big Endian byte order)
PCM_FORMAT_FLOAT64_LE	64 bit samples encoded as float (Little Endian byte order)
PCM_FORMAT_FLOAT64_BE	64 bit samples encoded as float (Big Endian byte order)
PCM_FORMAT_MU_LAW	A logarithmic encoding (used by Sun .au files and telephony)
PCM_FORMAT_A_LAW	Another logarithmic encoding
PCM_FORMAT_IMA_ADPCM	A 4:1 compressed format defined by the Interactive Multimedia Association.
PCM_FORMAT_MPEG	MPEG encoded audio?
PCM_FORMAT_GSM	9600 bits/s constant rate encoding for speech
PCM_FORMAT_S24_3LE	Signed 24 bit samples for each channel (Little Endian byte order in 3 bytes)
PCM_FORMAT_S24_3BE	Signed 24 bit samples for each channel (Big Endian byte order in 3 bytes)
PCM_FORMAT_U24_3LE	Unsigned 24 bit samples for each channel (Little Endian byte order in 3 bytes)
PCM_FORMAT_U24_3BE	Unsigned 24 bit samples for each channel (Big Endian byte order in 3 bytes)

• periodsize - the period size in frames. Make sure you understand the meaning of periods. The default value is 32, which is below the actual minimum of most devices, and will therefore likely be larger in practice.

• periods - the number of periods in the buffer. The default value is 4.

• device - the name of the PCM device that should be used (for example a value from the output of pcms()). The default value is 'default'.

• cardindex - the card index. If this argument is given, the device name is constructed as ‘hw:cardindex’ and the device keyword argument is ignored. 0 is the first hardware sound card.

  Note: This should not be used, as it bypasses most of ALSA’s configuration.

The defaults mentioned above are values passed by :mod:alsaaudio to ALSA, not anything internal to ALSA.

Note: For default and non-default values alike, there is no guarantee that a PCM device supports the requested configuration, and ALSA may pick realizable values which it believes to be closest to the request. Therefore, after creating a PCM object, it is necessary to verify whether its realized configuration is acceptable. The :func:info method can be used to query it.

Changed in 0.10:

• Added the optional named parameter periods.

Changed in 0.9:

• Added the optional named parameters rate, channels, format and periodsize.

Changed in 0.8:

• The card keyword argument is still supported, but deprecated. Please use device instead.

• The keyword argument cardindex was added.

The card keyword is deprecated because it guesses the real ALSA name of the card. This was always fragile and broke some legitimate usecases.

PCM objects have the following methods:

PCM.info() → dict

Returns a dictionary containing the configuration of a PCM device.

A small subset of properties reflects fixed parameters given by the user, stored within alsaaudio. To distinguish them from properties retrieved from ALSA when the call is made, they have their name prefixed with “ (call value) “.

Descriptions of properties which can be directly set during PCM object instantiation carry the prefix “PCM():”, followed by the respective constructor parameter. Note that due to device limitations, the values may deviate from those originally requested.

Yet another set of properties cannot be set, and derives directly from the hardware, possibly depending on other properties. Those properties’ descriptions are prefixed with “hw:” below.

Key	Description (Reference)	Type
name	PCM():device	string
card_no	index of card	integer (negative indicates device not associable with a card)
device_no	index of PCM device	integer
subdevice_no	index of PCM subdevice	integer
state	name of PCM state	string
access_type	name of PCM access type	string
(call value) type	PCM():type	integer
(call value) type_name	PCM():type	string
(call value) mode	PCM():mode	integer
(call value) mode_name	PCM():mode	string
format	PCM():format	integer
format_name	PCM():format	string
format_description	PCM():format	string
subformat_name	name of PCM subformat	string
subformat_description	description of subformat	string
channels	PCM():channels	integer
rate	PCM():rate	integer (Hz)
period_time	period duration	integer (\(\mu s\))
period_size	PCM():period_size	integer (frames)
buffer_time	buffer time	integer (\(\mu s\)) (negative indicates error)
buffer_size	buffer size	integer (frames) (negative indicates error)
get_periods	approx. periods in buffer	integer (negative indicates error)
rate_numden	numerator, denominator	tuple (integer (Hz), integer (Hz))
significant_bits	significant bits in sample [1]	integer (negative indicates error)
nominal_bits	nominal bits in sample [1]	integer (negative indicates error)
physical_bits	sample width in bits [1]	integer (negative indicates error)
is_batch	hw: double buffering	boolean (True: hardware supported)
is_block_transfer	hw: block transfer	boolean (True: hardware supported)
is_double	hw: double buffering	boolean (True: hardware supported)
is_half_duplex	hw: half-duplex	boolean (True: hardware supported)
is_joint_duplex	hw: joint-duplex	boolean (True: hardware supported)
can_overrange	hw: overrange detection	boolean (True: hardware supported)
can_mmap_sample_resolution	hw: sample-resol. mmap	boolean (True: hardware supported)
can_pause	hw: pause	boolean (True: hardware supported)
can_resume	hw: resume	boolean (True: hardware supported)
can_sync_start	hw: synchronized start	boolean (True: hardware supported)

[1] (1,2,3)

More information in the terminology section for sample size

The italicized descriptions give a summary of the “full” description as can be found in the ALSA documentation.

New in 0.9.1

PCM.dumpinfo()

Dumps the PCM object’s configured parameters to stdout.

PCM.pcmtype() → int

Returns the type of PCM object. Either PCM_CAPTURE or PCM_PLAYBACK.

PCM.pcmmode() → int

Return the mode of the PCM object. One of PCM_NONBLOCK, PCM_ASYNC, or PCM_NORMAL

PCM.cardname() → string

Return the name of the sound card used by this PCM object.

PCM.setchannels(nchannels: int) → int

Deprecated since version 0.9: Use the channels named argument to PCM().

PCM.setrate(rate: int) → int

Deprecated since version 0.9: Use the rate named argument to PCM().

PCM.setformat(format: int) → int

Deprecated since version 0.9: Use the format named argument to PCM().

PCM.setperiodsize(period: int) → int

Deprecated since version 0.9: Use the periodsize named argument to PCM().

PCM.state() → int

Returs the current state of the stream, which can be one of PCM_STATE_OPEN (this should not actually happen), PCM_STATE_SETUP (after drop() or drain()), PCM_STATE_PREPARED (after construction), PCM_STATE_RUNNING, PCM_STATE_XRUN, PCM_STATE_DRAINING, PCM_STATE_PAUSED, PCM_STATE_SUSPENDED, and PCM_STATE_DISCONNECTED.

New in 0.10

PCM.avail() → int

For PCM_PLAYBACK PCM objects, returns the number of writable (that is, free) frames in the buffer.

For PCM_CAPTURE PCM objects, returns the number of readable (that is, filled) frames in the buffer.

An attempt to read/write more frames than indicated will block (in PCM_NORMAL mode) or fail and return zero (in PCM_NONBLOCK mode).

New in 0.11

PCM.read() → tuple[int, bytes]

In PCM_NORMAL mode, this function blocks until a full period is available, and then returns a tuple (length,data) where length is the number of frames of captured data, and data is the captured sound frames as a string. The length of the returned data will be periodsize*framesize bytes.

In PCM_NONBLOCK mode, the call will not block, but will return (0,'') if no new period has become available since the last call to read.

In case of a buffer overrun, this function will return the negative size -EPIPE, and no data is read. This indicates that data was lost. To resume capturing, just call read again, but note that the stream was already corrupted. To avoid the problem in the future, try using a larger period size and/or more periods, at the cost of higher latency.

PCM.write(data: bytes) → int

Writes (plays) the sound in data. The length of data must be a multiple of the frame size, and should be exactly the size of a period. If less than ‘period size’ frames are provided, the actual playout will not happen until more data is written.

If the data was successfully written, the call returns the size of the data in frames.

If the device is not in PCM_NONBLOCK mode, this call will block if the kernel buffer is full, and until enough sound has been played to allow the sound data to be buffered.

In PCM_NONBLOCK mode, the call will return immediately, with a return value of zero, if the buffer is full. In this case, the data should be written again at a later time.

In case of a buffer underrun, this function will return the negative size -EPIPE, and no data is written. At this point, the playback was already corrupted. If you want to play the data nonetheless, call write again with the same data. To avoid the problem in the future, try using a larger period size and/or more periods, at the cost of higher latency.

Note that this call completing means only that the samples were buffered in the kernel, and playout will continue afterwards. Make sure that the stream is drained before discarding the PCM handle.

PCM.pause([enable: int = True]) → int

If enable is True, playback or capture is paused. Otherwise, playback/capture is resumed.

PCM.drop() → int

Stop the stream and drop residual buffered frames.

New in 0.9

PCM.drain() → int

For PCM_PLAYBACK PCM objects, play residual buffered frames and then stop the stream. In PCM_NORMAL mode, this function blocks until all pending playback is drained.

For PCM_CAPTURE PCM objects, this function is not very useful.

New in 0.10

PCM.close() → None

Closes the PCM device.

For PCM_PLAYBACK PCM objects in PCM_NORMAL mode, this function blocks until all pending playback is drained.

PCM.polldescriptors() → list[tuple[int, int]]

Returns a list of tuples of (file descriptor, eventmask) that can be used to wait for changes on the PCM with select.poll.

The eventmask value is compatible with `poll.register`__ in the Python select module.

PCM.polldescriptors_revents(descriptors: list[tuple[int, int]]) → int

Processes the descriptor list returned by polldescriptors() after using it with select.poll, and returns a single eventmask value that is meaningful for deciding whether read() or write() should be called.

New in 0.11

PCM.set_tstamp_mode([mode: int = PCM_TSTAMP_ENABLE])

Set the ALSA timestamp mode on the device. The mode argument can be set to either PCM_TSTAMP_NONE or PCM_TSTAMP_ENABLE.

PCM.get_tstamp_mode() → int

Return the integer value corresponding to the ALSA timestamp mode. The return value can be either PCM_TSTAMP_NONE or PCM_TSTAMP_ENABLE.

PCM.set_tstamp_type([type: int = PCM_TSTAMP_TYPE_GETTIMEOFDAY]) → None

Set the ALSA timestamp mode on the device. The type argument can be set to either PCM_TSTAMP_TYPE_GETTIMEOFDAY, PCM_TSTAMP_TYPE_MONOTONIC or PCM_TSTAMP_TYPE_MONOTONIC_RAW.

PCM.get_tstamp_type() → int

Return the integer value corresponding to the ALSA timestamp type. The return value can be either PCM_TSTAMP_TYPE_GETTIMEOFDAY, PCM_TSTAMP_TYPE_MONOTONIC or PCM_TSTAMP_TYPE_MONOTONIC_RAW.

PCM.htimestamp() → tuple[int, int, int]

Return a Python tuple (seconds, nanoseconds, frames_available_in_buffer).

The type of output is controlled by the tstamp_type, as described in the table below.

Timestamp Type	Description
PCM_TSTAMP_TYPE_GETTIMEOFDAY	System-wide realtime clock with seconds since epoch.
PCM_TSTAMP_TYPE_MONOTONIC	Monotonic time from an unspecified starting time. Progress is NTP synchronized.
PCM_TSTAMP_TYPE_MONOTONIC_RAW	Monotonic time from an unspecified starting time using only the system clock.

The timestamp mode is controlled by the tstamp_mode, as described in the table below.

Timestamp Mode	Description
PCM_TSTAMP_NONE	No timestamp.
PCM_TSTAMP_ENABLE	Update timestamp at every hardware position update.

A few hints on using PCM devices for playback

The most common reason for problems with playback of PCM audio is that writes to PCM devices must exactly match the data rate of the device.

If too little data is written to the device, it will underrun, and ugly clicking sounds will occur. Conversely, if too much data is written to the device, the write function will either block (PCM_NORMAL mode) or return zero (PCM_NONBLOCK mode).

If your program does nothing but play sound, the best strategy is to put the device in PCM_NORMAL mode, and just write as much data to the device as possible. This strategy can also be achieved by using a separate thread with the sole task of playing out sound.

In GUI programs, however, it may be a better strategy to setup the device, preload the buffer with a few periods by calling write a couple of times, and then use some timer method to write one period size of data to the device every period. The purpose of the preloading is to avoid underrun clicks if the used timer doesn’t expire exactly on time.

Also note, that most timer APIs that you can find for Python will accummulate time delays: If you set the timer to expire after 1/10’th of a second, the actual timeout will happen slightly later, which will accumulate to quite a lot after a few seconds. Hint: use time.time() to check how much time has really passed, and add extra writes as nessecary.

Mixer Objects

Mixer objects provides access to the ALSA mixer API.

class alsaaudio.Mixer(control: str = 'Master', id: int = 0, cardindex: int = -1, device: str = 'default') → Mixer

Arguments are:

• control - specifies which control to manipulate using this mixer object. The list of available controls can be found with the alsaaudio.mixers() function. The default value is 'Master' - other common controls may be 'Master Mono', 'PCM', 'Line', etc.

• id - the id of the mixer control. Default is 0.

• cardindex - specifies which card should be used. If this argument is given, the device name is constructed like this: ‘hw:cardindex’ and the device keyword argument is ignored. 0 is the first sound card.

• device - the name of the device on which the mixer resides. The default value is 'default'.

Changed in 0.8:

• The keyword argument device is new and can be used to select virtual devices.

Mixer objects have the following methods:

Mixer.cardname() → str

Return the name of the sound card used by this Mixer object

Mixer.mixer() → str

Return the name of the specific mixer controlled by this object, For example 'Master' or 'PCM'

Mixer.mixerid() → int

Return the ID of the ALSA mixer controlled by this object.

Mixer.switchcap() → int

Returns a list of the switches which are defined by this specific mixer. Possible values in this list are:

Switch	Description
‘Mute’	This mixer can mute
‘Joined Mute’	This mixer can mute all channels at the same time
‘Playback Mute’	This mixer can mute the playback output
‘Joined Playback Mute’	Mute playback for all channels at the same time}
‘Capture Mute’	Mute sound capture
‘Joined Capture Mute’	Mute sound capture for all channels at a time}
‘Capture Exclusive’	Not quite sure what this is

To manipulate these switches use the setrec() or setmute() methods

Mixer.volumecap() → int

Returns a list of the volume control capabilities of this mixer. Possible values in the list are:

Capability	Description
‘Volume’	This mixer can control volume
‘Joined Volume’	This mixer can control volume for all channels at the same time
‘Playback Volume’	This mixer can manipulate the playback output
‘Joined Playback Volume’	Manipulate playback volumne for all channels at the same time
‘Capture Volume’	Manipulate sound capture volume
‘Joined Capture Volume’	Manipulate sound capture volume for all channels at a time

Mixer.getenum() → tuple[str, list[str]]

For enumerated controls, return the currently selected item and the list of items available.

Returns a tuple (string, list of strings).

For example, my soundcard has a Mixer called Mono Output Select. Using amixer, I get:

$ amixer get "Mono Output Select"
Simple mixer control 'Mono Output Select',0
  Capabilities: enum
  Items: 'Mix' 'Mic'
  Item0: 'Mix'

Using alsaaudio, one could do:

>>> import alsaaudio
>>> m = alsaaudio.Mixer('Mono Output Select')
>>> m.getenum()
('Mix', ['Mix', 'Mic'])

This method will return an empty tuple if the mixer is not an enumerated control.

Mixer.setenum(index: int) → None

For enumerated controls, sets the currently selected item. index is an index into the list of available enumerated items returned by getenum().

Mixer.getrange(pcmtype: int = PCM_PLAYBACK, units: int = VOLUME_UNITS_RAW) → tuple[int, int]

Return the volume range of the ALSA mixer controlled by this object. The value is a tuple of integers whose meaning is determined by the units argument.

The optional pcmtype argument can be either PCM_PLAYBACK or PCM_CAPTURE, which is relevant if the mixer can control both playback and capture volume. The default value is PCM_PLAYBACK if the mixer has playback channels, otherwise it is PCM_CAPTURE.

The optional units argument can be one of VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.

Mixer.getvolume(pcmtype: int = PCM_PLAYBACK, units: int = VOLUME_UNITS_PERCENTAGE) → int

Returns a list with the current volume settings for each channel. The list elements are integers whose meaning is determined by the units argument.

The optional pcmtype argument can be either PCM_PLAYBACK or PCM_CAPTURE, which is relevant if the mixer can control both playback and capture volume. The default value is PCM_PLAYBACK if the mixer has playback channels, otherwise it is PCM_CAPTURE.

The optional units argument can be one of VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.

Mixer.setvolume(volume: int, pcmtype: int = PCM_PLAYBACK, units: int = VOLUME_UNITS_PERCENTAGE, channel: int | None = None) → None

Change the current volume settings for this mixer. The volume argument is an integer whose meaning is determined by the units argument.

If the optional argument channel is present, the volume is set only for this channel. This assumes that the mixer can control the volume for the channels independently.

The optional pcmtype argument can be either PCM_PLAYBACK or PCM_CAPTURE, which is relevant if the mixer can control both playback and capture volume. The default value is PCM_PLAYBACK if the mixer has playback channels, otherwise it is PCM_CAPTURE.

The optional units argument can be one of VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.

Mixer.getmute() → list[int]

Return a list indicating the current mute setting for each channel. 0 means not muted, 1 means muted.

This method will fail if the mixer has no playback switch capabilities.

Mixer.setmute(mute: bool, channel: int | None = None) → None

Sets the mute flag to a new value. The mute argument is either 0 for not muted, or 1 for muted.

The optional channel argument controls which channel is muted. The default is to set the mute flag for all channels.

This method will fail if the mixer has no playback mute capabilities

Mixer.getrec() → list[int]

Return a list indicating the current record mute setting for each channel. 0 means not recording, 1 means recording.

This method will fail if the mixer has no capture switch capabilities.

Mixer.setrec(capture: int, channel: int | None = None) → None

Sets the capture mute flag to a new value. The capture argument is either 0 for no capture, or 1 for capture.

The optional channel argument controls which channel is changed. The default is to set the capture flag for all channels.

This method will fail if the mixer has no capture switch capabilities.

Mixer.polldescriptors() → list[tuple[int, int]]

Returns a list of tuples of (file descriptor, eventmask) that can be used to wait for changes on the mixer with select.poll.

The eventmask value is compatible with `poll.register`__ in the Python select module.

Mixer.handleevents() → int

Acknowledge events on the polldescriptors() file descriptors to prevent subsequent polls from returning the same events again. Returns the number of events that were acknowledged.

Mixer.close() → None

Closes the Mixer device.

A rant on the ALSA Mixer API

The ALSA mixer API is extremely complicated - and hardly documented at all. alsaaudio implements a much simplified way to access this API. In designing the API I’ve had to make some choices which may limit what can and cannot be controlled through the API. However, if I had chosen to implement the full API, I would have reexposed the horrible complexity/documentation ratio of the underlying API. At least the alsaaudio API is easy to understand and use.

If my design choises prevents you from doing something that the underlying API would have allowed, please let me know, so I can incorporate these needs into future versions.

If the current state of affairs annoys you, the best you can do is to write a HOWTO on the API and make this available on the net. Until somebody does this, the availability of ALSA mixer capable devices will stay quite limited.

Unfortunately, I’m not able to create such a HOWTO myself, since I only understand half of the API, and that which I do understand has come from a painful trial and error process.

Examples

The following example are provided:

• playwav.py

• recordtest.py

• playbacktest.py

• mixertest.py

All examples (except mixertest.py) accept the commandline option -c <cardname>.

To determine a valid card name, use the commandline ALSA player:

$ aplay -L

or:

$ python

>>> import alsaaudio
>>> alsaaudio.pcms()

mixertest.py accepts the commandline options -d <device> and -c <cardindex>.

playwav.py

playwav.py plays a wav file.

To test PCM playback (on your default soundcard), run:

$ python playwav.py <wav file>

recordtest.py and playbacktest.py

recordtest.py and playbacktest.py will record and play a raw sound file in CD quality.

To test PCM recordings (on your default soundcard), run:

$ python recordtest.py <filename>

Speak into the microphone, and interrupt the recording at any time with Ctl-C.

Play back the recording with:

$ python playbacktest.py <filename>

mixertest.py

Without arguments, mixertest.py will list all available controls on the default soundcard.

The output might look like this:

$ ./mixertest.py
Available mixer controls:
   'Master'
   'Master Mono'
   'Headphone'
   'PCM'
   'Line'
   'Line In->Rear Out'
   'CD'
   'Mic'
   'PC Speaker'
   'Aux'
   'Mono Output Select'
   'Capture'
   'Mix'
   'Mix Mono'

With a single argument - the control, it will display the settings of that control; for example:

$ ./mixertest.py Master
Mixer name: 'Master'
Capabilities: Playback Volume Playback Mute
Channel 0 volume: 61%
Channel 1 volume: 61%

With two arguments, the control and a parameter, it will set the parameter on the mixer:

$ ./mixertest.py Master mute

This will mute the Master mixer.

Or:

$ ./mixertest.py Master 40

This sets the volume to 40% on all channels.

To select a different soundcard, use either the device or cardindex argument:

$ ./mixertest.py -c 0 Master
Mixer name: 'Master'
Capabilities: Playback Volume Playback Mute
Channel 0 volume: 61%
Channel 1 volume: 61%