PyAlsaAudio

http://larsimmisch.github.io/pyalsaaudio/
Admin
PyAlsaAudio is a Python interface to the Advanced Linux Sound Architecture (ALSA), providing full...
Tokens:16,218
Snippets:221
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/pyalsaaudio.rst.txt

Use this command to install the PyAlsaAudio package. Ensure you have the alsa-lib package and its development headers installed.

```bash
$ pip install .
```

--------------------------------

### Install PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/pyalsaaudio.html

Use pip to install the PyAlsaAudio package. Ensure ALSA development headers and libraries are installed beforehand.

```bash
$
pip install .

```

--------------------------------

### GET PCM.info()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the current configuration of a PCM device as a dictionary.

```APIDOC
## GET PCM.info()

### Description
Returns a dictionary containing the configuration of a PCM device. Properties are prefixed to indicate if they are call values, constructor parameters, or hardware-derived values.

### Method
GET

### Response
#### Success Response (200)
- **name** (string) - PCM():device
- **card_no** (integer) - index of card (negative indicates device not associable with a card)
- **device_no** (integer) - index of PCM device
- **subdevice_no** (integer) - index of PCM subdevice
- **state** (string) - name of PCM state
- **access_type** (string) - name of PCM access type
```

--------------------------------

### Volume Control Methods

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Methods for getting and setting volume levels and ranges.

```APIDOC
## Mixer.getrange(pcmtype, units)

### Description
Return the volume range of the ALSA mixer controlled by this object.

### Parameters
- **pcmtype** (int) - Optional - PCM_PLAYBACK or PCM_CAPTURE.
- **units** (int) - Optional - VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.

### Response
- **Return** (tuple[int, int]) - The volume range.

## Mixer.getvolume(pcmtype, units)

### Description
Returns a list with the current volume settings for each channel.

### Parameters
- **pcmtype** (int) - Optional - PCM_PLAYBACK or PCM_CAPTURE.
- **units** (int) - Optional - VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.

### Response
- **Return** (list) - List of integers representing volume settings.

## Mixer.setvolume(volume, pcmtype, units, channel)

### Description
Change the current volume settings for this mixer.

### Parameters
- **volume** (int) - Required - The volume value.
- **pcmtype** (int) - Optional - PCM_PLAYBACK or PCM_CAPTURE.
- **units** (int) - Optional - VOLUME_UNITS_PERCENTAGE, VOLUME_UNITS_RAW, or VOLUME_UNITS_DB.
- **channel** (int) - Optional - Specific channel index.
```

--------------------------------

### Set Mixer Control Volume Example

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Sets the volume for a specific mixer control (e.g., 'Master') to a given percentage when mixertest.py is run with the control name and a numeric volume level as arguments.

```bash
$ ./mixertest.py Master 40
```

--------------------------------

### Get Switch Capabilities

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns a list of switch capabilities for the mixer, such as muting or playback mute.

```python
m.switchcap()
```

--------------------------------

### Get Volume Capabilities

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns a list of volume control capabilities for the mixer, such as controlling overall volume or playback volume.

```python
m.volumecap()
```

--------------------------------

### Get ALSA Library Version

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieves and returns the version of the ALSA library that the module is linked against.

```python
import alsaaudio

print(alsaaudio.asoundlib_version())

```

--------------------------------

### Get ALSA Library Version

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the version of the ALSA library that the module is using.

```APIDOC
## GET /api/asoundlib_version

### Description
Returns a string containing the ALSA library version found.

### Method
GET

### Endpoint
/api/asoundlib_version

### Response
#### Success Response (200)
- **version** (str) - The ALSA library version string.

### Response Example
```json
{
  "version": "1.2.7"
}
```
```

--------------------------------

### Get Mixer Card Name

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieve the name of the sound card associated with this Mixer object.

```python
m.cardname()
```

--------------------------------

### Get Enumerated Control Info

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieve the current selection and available options for an enumerated mixer control. Returns an empty tuple if the control is not enumerated.

```python
('Mix', ['Mix', 'Mic'])
```

--------------------------------

### Get Current Volume

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieve the current volume setting(s) for each channel. The units can be specified as percentage, raw, or dB.

```python
m.getvolume()
```

--------------------------------

### Mute Mixer Control Example

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Mutes a specific mixer control (e.g., 'Master') when mixertest.py is run with the control name and 'mute' as arguments.

```bash
$ ./mixertest.py Master mute
```

--------------------------------

### Get Mixer Name

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Return the name of the specific mixer control being managed by this object (e.g., 'Master' or 'PCM').

```python
m.mixer()
```

--------------------------------

### Set Mixer Control Parameter (Mute)

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Use mixertest.py with a control and a parameter to modify mixer settings. For example, 'mute' will silence the specified control.

```bash
$ ./mixertest.py Master mute


```

--------------------------------

### Get Volume Range

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Obtain the minimum and maximum volume levels for a mixer control. You can specify whether to query playback or capture volume, and the units (percentage, raw, or dB).

```python
m.getrange()
```

--------------------------------

### Get Mixer Record Status

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Returns the current record mute setting for each channel. A value of 0 means not recording, and 1 means recording. This method requires the mixer to have capture switch capabilities.

```python
mixer.getrec()
```

--------------------------------

### List ALSA devices via command line

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Use the aplay utility to list available sound card devices.

```bash
$ aplay -L
```

--------------------------------

### Play a WAV file

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Run the playwav.py script to test PCM playback on the default soundcard.

```bash
$ python playwav.py <wav file>
```

--------------------------------

### List Available Mixer Controls

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Run mixertest.py without arguments to list all available mixer controls on the default soundcard. This helps identify controllable audio parameters.

```bash
$ ./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'


```

--------------------------------

### Get Mixer ID

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Return the ALSA mixer ID for the control managed by this object.

```python
m.mixerid()
```

--------------------------------

### Select Soundcard and Display Mixer Settings

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Use the '-c' or '--cardindex' argument with mixertest.py to specify a soundcard index and then display the settings for a control on that card.

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


```

--------------------------------

### PCM Constructor

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Initializes a new PCM object for audio playback or capture with specified hardware and software configurations.

```APIDOC
## PCM Constructor

### Description
Creates a PCM object to represent an audio device for either playback or recording. Note that ALSA may adjust requested values to match hardware capabilities.

### Parameters
#### Request Body
- **type** (int) - Optional - PCM_CAPTURE or PCM_PLAYBACK (default).
- **mode** (int) - Optional - PCM_NONBLOCK or PCM_NORMAL (default).
- **rate** (int) - Optional - Sampling rate in Hz (default 44100).
- **channels** (int) - Optional - Number of channels (default 2).
- **format** (int) - Optional - Data format (default PCM_FORMAT_S16_LE).
- **periodsize** (int) - Optional - Period size in frames (default 32).
- **periods** (int) - Optional - Number of periods in the buffer (default 4).
- **device** (str) - Optional - Name of the PCM device (default 'default').
- **cardindex** (int) - Optional - Card index to construct device name as 'hw:cardindex'.
```

--------------------------------

### List ALSA devices via Python

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Use the alsaaudio module to programmatically list available PCM devices.

```python
>>> import alsaaudio
>>> alsaaudio.pcms()
```

--------------------------------

### List Available Mixer Controls

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Lists all available mixer controls on the default soundcard when mixertest.py is run without arguments.

```bash
$ ./mixertest.py
```

--------------------------------

### Mixer Object Initialization and Methods

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Details on creating and using Mixer objects to control ALSA audio mixers.

```APIDOC
## Mixer Class

### Description
Mixer objects provide access to the ALSA mixer API for controlling audio levels and other mixer settings.

### Method
GET

### Endpoint
Mixer()

### Parameters
#### Path Parameters
- **control** (str) - Optional - Specifies which control to manipulate. Defaults to 'Master'.
- **id** (int) - Optional - The ID of the mixer control. Defaults to 0.
- **cardindex** (int) - Optional - The index of the sound card to use. Defaults to -1.
- **device** (str) - Optional - The name of the device on which the mixer resides. Defaults to 'default'.

### Changed in 0.8:
- The keyword argument `device` is new and can be used to select virtual devices.

## Mixer.cardname()

### Description
Return the name of the sound card used by this Mixer object.

### Method
GET

### Endpoint
Mixer.cardname()

### Response
#### Success Response (200)
- **return_value** (str) - The name of the sound card.

## Mixer.mixer()

### Description
Returns the mixer control name.

### Method
GET

### Endpoint
Mixer.mixer()

### Response
#### Success Response (200)
- **return_value** (str) - The name of the mixer control.
```

--------------------------------

### List Available PCM Playback Devices

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available PCM playback devices. This is equivalent to running `aplay -L` on the command line.

```python
import alsaaudio

print(alsaaudio.pcms(alsaaudio.PCM_PLAYBACK))

```

--------------------------------

### List Available PCM Devices

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Lists available PCM devices using the alsaaudio library in a Python interpreter.

```python
import alsaaudio
alsaaudio.pcms()
```

--------------------------------

### Record raw audio

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Run the recordtest.py script to record audio to a raw file.

```bash
$ python recordtest.py <filename>
```

--------------------------------

### Retrieve Enumerated Control Settings

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Demonstrates how to fetch the current selection and available options for an enumerated mixer control.

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

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

--------------------------------

### PCM.info()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieves a dictionary containing the current configuration and hardware properties of a PCM device.

```APIDOC
## PCM.info()

### Description
Returns a dictionary containing the configuration of a PCM device, including user-defined parameters and hardware-derived properties.

### Response
#### Success Response (200)
- **name** (string) - PCM device name
- **card_no** (integer) - Index of card
- **device_no** (integer) - Index of PCM device
- **subdevice_no** (integer) - Index of PCM subdevice
- **state** (string) - Name of PCM state
- **access_type** (string) - Name of PCM access type
- **channels** (integer) - Number of channels
- **rate** (integer) - Sample rate in Hz
- **is_batch** (boolean) - Hardware supported batch processing
- **is_block_transfer** (boolean) - Hardware supported block transfer
```

--------------------------------

### Test PCM Recording with PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/pyalsaaudio.rst.txt

Use this script to test PCM audio recording. Speak into the microphone and interrupt with Ctrl-C. Ensure the specified device is correct.

```bash
$ python recordtest.py -d <device> <filename>
```

--------------------------------

### PCM Object Constructor

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Represents a PCM device for playback or recording.

```APIDOC
## POST /api/pcm

### Description
Initializes and returns a PCM object for playback or recording.

### Method
POST

### Endpoint
/api/pcm

#### Request Body
- **type** (int) - Optional - Can be either PCM_CAPTURE or PCM_PLAYBACK (default).
- **mode** (int) - Optional - Can be either PCM_NONBLOCK, or PCM_NORMAL (default).
- **rate** (int) - Optional - The sampling rate in Hz. Default is 44100.
- **channels** (int) - Optional - The number of channels. Default is 2 (stereo).
- **format** (int) - Optional - The data format. Default is PCM_FORMAT_S16_LE.
- **periodsize** (int) - Optional - The size of the period in frames. Default is 32.
- **periods** (int) - Optional - The number of periods. Default is 4.
- **device** (str) - Optional - The name of the PCM device. Default is 'default'.
- **cardindex** (int) - Optional - The card index. Default is -1.

### Request Example
```json
{
  "type": 1, 
  "rate": 48000,
  "channels": 1,
  "format": 1048576
}
```

### Response
#### Success Response (200)
- **pcm_object_id** (str) - An identifier for the created PCM object.

#### Response Example
```json
{
  "pcm_object_id": "pcm_12345"
}
```
```

--------------------------------

### Get Mixer Mute Status

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the mute status for each channel of the mixer. Returns a list where 0 indicates not muted and 1 indicates muted. This method requires the mixer to have playback switch capabilities.

```python
mixer.getmute()
```

--------------------------------

### Initialize ALSA Mixer Object

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Instantiate a Mixer object to control a specific ALSA mixer. You can specify the control name, ID, card index, and device name.

```python
import alsaaudio
m = alsaaudio.Mixer('Mono Output Select')
```

--------------------------------

### Play back raw audio

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Run the playbacktest.py script to play back a previously recorded raw sound file.

```bash
$ python playbacktest.py <filename>
```

--------------------------------

### List Available PCM Capture Devices

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available PCM capture devices. This is equivalent to running `arecord -L` on the command line.

```python
import alsaaudio

print(alsaaudio.pcms(alsaaudio.PCM_CAPTURE))

```

--------------------------------

### Display Mixer Control Settings

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Displays the capabilities and current settings (e.g., volume percentage) for a specific mixer control when mixertest.py is run with a control name as an argument.

```bash
$ ./mixertest.py Master
```

--------------------------------

### PCM.avail

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Returns the number of available frames for reading or writing.

```APIDOC
## PCM.avail

### Description
For playback PCM objects, returns the number of writable (free) frames. For capture PCM objects, returns the number of readable (filled) frames.

### Method
`avail()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (int) - The number of available frames.

### Response Example
```python
# Example: Get available frames
available_frames = pcm.avail()
print(f"Available frames: {available_frames}")
```
```

--------------------------------

### Set Volume to 40% on All Channels

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

This command sets the volume to 40% on all channels of the default audio device. To select a different soundcard, use the *device* or *cardindex* argument.

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

--------------------------------

### Play WAV file with PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/pyalsaaudio.html

Play a WAV file using the playwav.py script. Specify the device if your default soundcard is not suitable.

```bash
$ python playwav.py <filename.wav>

```

```bash
$ python playwav.py -d hw:CARD=sndrpihifiberry,DEV=0 <filename.wav>

```

--------------------------------

### PCM Hardware Capabilities

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Methods for querying supported device configurations and hardware capabilities.

```APIDOC
## PCM.getchannels()

### Description
Returns list of the device's supported channel counts.

## PCM.getratebounds()

### Description
Returns the card's minimum and maximum supported sample rates.

### Response
- **bounds** (tuple) - A tuple of integers (min, max).

## PCM.getrates()

### Description
Returns the sample rates supported by the device.

## PCM.getformats()

### Description
Returns a dictionary of supported format codes keyed by their standard ALSA names.

### Response
- **formats** (dict) - Dictionary of format codes (int) keyed by names (string).
```

--------------------------------

### List Mixers for Specific Device Name

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available mixer controls for a specified device name. This is equivalent to `amixer -D <device>`.

```python
import alsaaudio

print(alsaaudio.mixers(device='foo'))

```

--------------------------------

### Playback recorded audio with PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/pyalsaaudio.html

Play back a previously recorded audio file using the playbacktest.py script, specifying the device used for recording.

```bash
$ python playbacktest.py -d <device> <filename>

```

--------------------------------

### Display Mixer Control Settings

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Provide a mixer control name as an argument to mixertest.py to view its current settings and capabilities. This is useful for understanding a control's behavior.

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


```

--------------------------------

### alsaaudio.asoundlib_version

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns a string containing the ALSA version found.

```APIDOC
## alsaudio.asoundlib_version

### Description
Return a Python string containing the ALSA version found.

### Method
`alsaaudio.asoundlib_version`

### Endpoint
`/alsaaudio/asoundlib_version`
```

--------------------------------

### alsaaudio.PCM Methods

Source: http://larsimmisch.github.io/pyalsaaudio/genindex.html

Methods available for the PCM class to handle audio stream playback and capture.

```APIDOC
## PCM Methods

### Description
Methods for managing PCM audio streams, including reading, writing, and configuration.

### Methods
- **avail()**: Returns available space in the buffer.
- **close()**: Closes the PCM device.
- **drain()**: Drains the buffer.
- **drop()**: Drops the buffer.
- **dumpinfo()**: Dumps PCM information.
- **read()**: Reads data from the PCM device.
- **write()**: Writes data to the PCM device.
- **setchannels()**: Sets the number of channels.
- **setformat()**: Sets the audio format.
- **setrate()**: Sets the sample rate.
- **setperiodsize()**: Sets the period size.
```

--------------------------------

### PCM Object Methods

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Methods for retrieving information about the current PCM object configuration and hardware capabilities.

```APIDOC
## PCM.dumpinfo()

### Description
Dumps the PCM object's configured parameters to stdout.

## PCM.pcmtype()

### Description
Returns the type of PCM object.

### Response
- **type** (int) - Either PCM_CAPTURE or PCM_PLAYBACK.

## PCM.pcmmode()

### Description
Return the mode of the PCM object.

### Response
- **mode** (int) - One of PCM_NONBLOCK, PCM_ASYNC, or PCM_NORMAL.

## PCM.cardname()

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

### Response
- **name** (string) - The name of the sound card.
```

--------------------------------

### Record PCM with PyAlsaAudio

Source: http://larsimmisch.github.io/pyalsaaudio/pyalsaaudio.html

Record audio from a specified device to a file using the recordtest.py script. Interrupt recording with Ctrl+C.

```bash
$ python recordtest.py -d <device> <filename>

```

--------------------------------

### PCM.avail()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns the number of available frames in the buffer for playback or capture streams.

```APIDOC
## PCM.avail()

### Description
For PCM_PLAYBACK objects, returns writable frames. For PCM_CAPTURE objects, returns readable frames.

### Response
#### Success Response (200)
- **frames** (integer) - Number of frames available in the buffer.
```

--------------------------------

### List Mixers for Default Device

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available mixer controls for the default ALSA device. This is useful for inspecting available audio controls.

```python
import alsaaudio

print(alsaaudio.mixers())

```

--------------------------------

### Mixer Object Initialization

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Initializes a new Mixer object to interact with a specific ALSA control.

```APIDOC
## Constructor Mixer(control, id, cardindex, device)

### Description
Creates a new Mixer object to manipulate a specific ALSA control.

### Parameters
#### Request Body
- **control** (str) - Optional - The name of the control to manipulate (default: 'Master').
- **id** (int) - Optional - The ID of the mixer control (default: 0).
- **cardindex** (int) - Optional - The index of the sound card to use.
- **device** (str) - Optional - The name of the device (default: 'default').
```

--------------------------------

### PCM.write

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Writes audio data to the playback stream.

```APIDOC
## PCM.write

### Description
Writes audio data to the playback stream. The data length must be a multiple of the frame size and ideally a full period. In non-blocking mode, it returns 0 if the buffer is full. Handles buffer underruns by returning `-EPIPE`.

### Method
`write(data: bytes)`

### Endpoint
N/A (Method call)

### Parameters
#### Request Body
- **data** (bytes) - Required - The audio data to write.

### Response
#### Success Response (200)
- **return_value** (int) - The size of the data written in frames.

#### Error Response
- **return_value** (int) - `-EPIPE` in case of a buffer underrun.

### Request Example
```python
# Example: Write audio data
audio_data = b'...' # Your audio data
frames_written = pcm.write(audio_data)
if frames_written > 0:
    print(f"Successfully wrote {frames_written} frames.")
elif frames_written < 0:
    print(f"Buffer underrun: {frames_written}")
```
```

--------------------------------

### alsaaudio.mixers

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists the available mixers for a given card index or device name.

```APIDOC
## alsaudio.mixers

### Description
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:
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.

### Method
`alsaaudio.mixers`

### Parameters
#### Query Parameters
- **_cardindex_** (int) - Optional - 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.
- **_device_** (str) - Optional - The name of the device on which the mixer resides. The default is `'default'`.
```

--------------------------------

### alsaaudio.Mixer Methods

Source: http://larsimmisch.github.io/pyalsaaudio/genindex.html

Methods available for the Mixer class to control audio volume and settings.

```APIDOC
## Mixer Methods

### Description
Methods for controlling audio mixer settings such as volume, mute, and recording status.

### Methods
- **cardname()**: Returns the name of the mixer card.
- **close()**: Closes the mixer.
- **getvolume()**: Gets the current volume.
- **setvolume()**: Sets the volume.
- **getmute()**: Gets the mute status.
- **setmute()**: Sets the mute status.
- **getrec()**: Gets the recording status.
- **setrec()**: Sets the recording status.
- **getrange()**: Gets the volume range.
```

--------------------------------

### alsaaudio.cards

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists the available ALSA cards by name.

```APIDOC
## alsaudio.cards

### Description
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.

### Method
`alsaaudio.cards`

### Endpoint
`/alsaaudio/cards`
```

--------------------------------

### Listing PCM Devices

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Functions to list available PCM devices for playback or capture.

```APIDOC
## GET /api/pcms

### Description
Lists available PCM devices by name. You can specify whether to list playback or capture devices.

### Method
GET

### Endpoint
/api/pcms

#### Query Parameters
- **pcmtype** (int) - Optional - Can be either PCM_CAPTURE or PCM_PLAYBACK (default).

### Response
#### Success Response (200)
- **devices** (list[str]) - A list of available PCM device names.

### Response Example
```json
{
  "devices": ["default", "hw:0,0", "plughw:0,0"]
}
```
```

--------------------------------

### List Available ALSA Cards

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists the names of available ALSA cards. For a list of PCM devices, `pcms()` is generally more useful.

```python
import alsaaudio

print(alsaaudio.cards())

```

--------------------------------

### List Mixers for Specific Card Index

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available mixer controls for a specific ALSA card index. This bypasses most of ALSA's configuration and is equivalent to `amixer -c <cardindex>`.

```python
import alsaaudio

print(alsaaudio.mixers(cardindex=0))

```

--------------------------------

### Mixer Information Methods

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Methods to retrieve basic identification and capability information for a mixer instance.

```APIDOC
## Mixer.mixerid()

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

### Method
Method call

### Response
- **Return** (int) - The ID of the mixer.

## Mixer.switchcap()

### Description
Returns a list of the switches which are defined by this specific mixer.

### Response
- **Return** (list) - A list of switch capabilities such as 'Mute', 'Playback Mute', etc.

## Mixer.volumecap()

### Description
Returns a list of the volume control capabilities of this mixer.

### Response
- **Return** (list) - A list of volume capabilities such as 'Volume', 'Playback Volume', etc.
```

--------------------------------

### alsaaudio.pcms

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Lists available PCM devices by name. Can filter by playback or capture devices.

```APIDOC
## alsaudio.pcms

### Description
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.
For `PCM_CAPTURE`, the list of device names should be equivalent to the list of device names that `arecord -L` displays on the commandline.

_New in 0.8_

### Method
`alsaaudio.pcms`

### Parameters
#### Query Parameters
- **_pcmtype_** (int) - Optional - Can be either `PCM_CAPTURE` or `PCM_PLAYBACK` (default).
```

--------------------------------

### Mixer.handleevents()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Acknowledges events on the mixer.

```APIDOC
## POST Mixer.handleevents()

### Description
Acknowledge events on the polldescriptors() file descriptors to prevent subsequent polls from returning the same events again.

### Response
#### Success Response (200)
- **int** - The number of events that were acknowledged.
```

--------------------------------

### Listing Mixers

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Functions to list available mixers for ALSA audio devices.

```APIDOC
## GET /api/mixers

### Description
Lists the available mixers for a specified ALSA card or device.

### Method
GET

### Endpoint
/api/mixers

#### Query Parameters
- **cardindex** (int) - Optional - The card index. If provided, the device name is constructed as 'hw:*cardindex*' and the `device` keyword argument is ignored. Defaults to -1.
- **device** (str) - Optional - The name of the device on which the mixer resides. Defaults to 'default'.

### Response
#### Success Response (200)
- **mixers** (list[str]) - A list of available mixer control names.

### Response Example
```json
{
  "mixers": ["Master", "PCM", "Speaker"]
}
```
```

--------------------------------

### Enumerated Control Methods

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Methods for interacting with enumerated mixer controls.

```APIDOC
## Mixer.getenum()

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

### Response
- **Return** (tuple[str, list[str]]) - A tuple containing the current item and a list of available items.

## Mixer.setenum(index)

### Description
For enumerated controls, sets the currently selected item.

### Parameters
- **index** (int) - Required - An index into the list of available enumerated items.
```

--------------------------------

### alsaaudio Module Functions

Source: http://larsimmisch.github.io/pyalsaaudio/index.html

Core functions provided by the alsaaudio module to query system sound hardware and library information.

```APIDOC
## alsaaudio.pcms()

### Description
Returns a list of available PCM devices.

## alsaaudio.cards()

### Description
Returns a list of available sound cards.

## alsaaudio.mixers()

### Description
Returns a list of available mixer controls.

## alsaaudio.asoundlib_version()

### Description
Returns the version of the underlying ALSA library.
```

--------------------------------

### PCM.close

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Closes the PCM device and releases resources.

```APIDOC
## PCM.close

### Description
Closes the PCM device. For playback PCM objects in `PCM_NORMAL` mode, this method blocks until all pending playback is drained before closing.

### Method
`close()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (None) - Indicates successful closure.

### Response Example
```python
# Example: Close the PCM device
pcm.close()
```
```

--------------------------------

### Listing ALSA Cards

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Function to list available ALSA sound cards by name.

```APIDOC
## GET /api/cards

### Description
Lists the available ALSA sound cards by name. This function is generally less useful than `pcms` for identifying audio devices.

### Method
GET

### Endpoint
/api/cards

### Response
#### Success Response (200)
- **cards** (list[str]) - A list of available ALSA card names.

### Response Example
```json
{
  "cards": ["HDA Intel PCH", "USB Audio Device"]
}
```
```

--------------------------------

### PCM.read

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Reads audio data from the capture stream.

```APIDOC
## PCM.read

### Description
Reads audio data from the capture stream. In `PCM_NORMAL` mode, it blocks until a full period is available. In `PCM_NONBLOCK` mode, it returns immediately if no new period is available. Handles buffer overruns by returning `-EPIPE`.

### Method
`read()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (tuple[int, bytes]) - A tuple containing the number of frames read and the captured audio data.

#### Error Response
- **return_value** (int) - `-EPIPE` in case of a buffer overrun.

### Response Example
```python
# Example: Read audio data
length, data = pcm.read()
if length > 0:
    print(f"Read {length} frames of data.")
elif length < 0:
    print(f"Buffer overrun: {length}")
```
```

--------------------------------

### PCM Data Operations

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Methods for reading captured audio data and writing playback audio data.

```APIDOC
## PCM.read()

### Description
Reads captured sound frames from the device.

### Method
Method call

### Parameters
None

### Response
- **tuple[int, bytes]** - Returns (length, data) where length is the number of frames and data is the captured sound frames.

## PCM.write(data)

### Description
Writes (plays) the sound data to the device.

### Method
Method call

### Parameters
- **data** (bytes) - Required - The sound data to play.

### Response
- **int** - Returns the size of the data written in frames.
```

--------------------------------

### PCM.pcmtype()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns the type of the PCM object, indicating whether it is for capture or playback.

```APIDOC
## PCM.pcmtype()

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

### Response
#### Success Response (200)
- **type** (integer) - The PCM type constant.
```

--------------------------------

### Mixer.handleevents()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Acknowledges events on the polldescriptors file descriptors.

```APIDOC
## Mixer.handleevents()

### Description
Acknowledge events on the :func:`polldescriptors` file descriptors to prevent subsequent polls from returning the same events again. Returns the number of events that were acknowledged.

### Method
POST

### Endpoint
/mixer/handleevents

### Response
#### Success Response (200)
- **acknowledged_events** (int) - The number of events that were acknowledged.
```

--------------------------------

### PCM.state()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns the current state of the PCM stream.

```APIDOC
## PCM.state()

### Description
Returns the current state of the stream (e.g., RUNNING, PAUSED, PREPARED).

### Response
#### Success Response (200)
- **state** (integer) - The PCM state constant.
```

--------------------------------

### Mixer.polldescriptors()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Returns file descriptors for polling mixer events.

```APIDOC
## GET Mixer.polldescriptors()

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

--------------------------------

### Mixer.polldescriptors()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Returns file descriptors and event masks for polling mixer events.

```APIDOC
## Mixer.polldescriptors()

### Description
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 :const:`select` module.

### Method
GET

### Endpoint
/mixer/polldescriptors

### Response
#### Success Response (200)
- **descriptors** (list[tuple[int, int]]) - A list of tuples, where each tuple contains a file descriptor and an event mask.
```

--------------------------------

### Mixer Methods

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Methods available on Mixer objects to query and modify mixer settings.

```APIDOC
## Mixer Methods

### cardname()
Returns the name of the sound card used by the Mixer object.

### mixer()
Returns the name of the specific mixer controlled by this object.

### mixerid()
Returns the ID of the ALSA mixer controlled by this object.

### getenum()
Returns a tuple containing the currently selected item and a list of available items for enumerated controls.

### setenum(index)
Sets the currently selected item for enumerated controls using an index.

### getrange(pcmtype, units)
Returns the volume range of the mixer as a tuple of integers.

### getvolume(pcmtype, units)
Returns a list of current volume settings for each channel.

### setvolume(volume, pcmtype, units, channel)
Changes the current volume settings for the mixer.
```

--------------------------------

### Poll Mixer Events

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Returns a list of tuples containing file descriptors and event masks for waiting on mixer changes using `select.poll`. The event mask is compatible with `poll.register`.

```python
mixer.polldescriptors()
```

--------------------------------

### PCM.state

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the current state of the audio stream.

```APIDOC
## PCM.state

### Description
Returns the current state of the audio stream. Possible states include:
- `PCM_STATE_OPEN`
- `PCM_STATE_SETUP`
- `PCM_STATE_PREPARED`
- `PCM_STATE_RUNNING`
- `PCM_STATE_XRUN`
- `PCM_STATE_DRAINING`
- `PCM_STATE_PAUSED`
- `PCM_STATE_SUSPENDED`
- `PCM_STATE_DISCONNECTED`

### Method
`state()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (int) - The current state of the PCM stream.

### Response Example
```python
# Example: Get the current state
current_state = pcm.state()
print(f"Current state: {current_state}")
```
```

--------------------------------

### PCM Timestamp and Type Management

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

APIs for retrieving and setting timestamp modes and types for PCM devices.

```APIDOC
## PCM.get_tstamp_mode()

### Description
Return the integer value corresponding to the ALSA timestamp mode.

### Method
GET

### Endpoint
PCM.get_tstamp_mode()

### Response
#### Success Response (200)
- **return_value** (int) - The integer value of the timestamp mode (PCM_TSTAMP_NONE or PCM_TSTAMP_ENABLE).

## PCM.set_tstamp_type()

### Description
Set the ALSA timestamp mode on the device.

### Method
POST

### Endpoint
PCM.set_tstamp_type()

### Parameters
#### Query Parameters
- **type** (int) - Optional - The timestamp type (PCM_TSTAMP_TYPE_GETTIMEOFDAY, PCM_TSTAMP_TYPE_MONOTONIC, or PCM_TSTAMP_TYPE_MONOTONIC_RAW). Defaults to PCM_TSTAMP_TYPE_GETTIMEOFDAY.

### Response
#### Success Response (200)
- **None**

## PCM.get_tstamp_type()

### Description
Return the integer value corresponding to the ALSA timestamp type.

### Method
GET

### Endpoint
PCM.get_tstamp_type()

### Response
#### Success Response (200)
- **return_value** (int) - The integer value of the timestamp type (PCM_TSTAMP_TYPE_GETTIMEOFDAY, PCM_TSTAMP_TYPE_MONOTONIC, or PCM_TSTAMP_TYPE_MONOTONIC_RAW).

## PCM.htimestamp()

### Description
Return a Python tuple containing seconds, nanoseconds, and frames available in the buffer. The output type is controlled by `tstamp_type` and the mode by `tstamp_mode`.

### Method
GET

### Endpoint
PCM.htimestamp()

### Response
#### Success Response (200)
- **return_value** (tuple[int, int, int]) - A tuple containing (seconds, nanoseconds, frames_available_in_buffer).

### Timestamp Type Descriptions:
- ``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.

### Timestamp Mode Descriptions:
- ``PCM_TSTAMP_NONE``: No timestamp.
- ``PCM_TSTAMP_ENABLE``: Update timestamp at every hardware position update.
```

--------------------------------

### PCM Control and State

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Methods for managing the state of the PCM stream, including pausing, dropping, and draining.

```APIDOC
## PCM.pause(enable=True)

### Description
Pauses or resumes playback/capture.

### Parameters
- **enable** (int) - Optional - True to pause, False to resume.

## PCM.drop()

### Description
Stops the stream and drops residual buffered frames.

## PCM.drain()

### Description
For playback, plays residual buffered frames and stops. For capture, this is not useful.

## PCM.close()

### Description
Closes the PCM device.
```

--------------------------------

### Mixer.getrec()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieves the current recording mute status for each channel.

```APIDOC
## GET Mixer.getrec()

### Description
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.

### Response
#### Success Response (200)
- **list[int]** - A list of integers where 0 is not recording and 1 is recording.
```

--------------------------------

### Mixer.close()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Closes the mixer device.

```APIDOC
## POST Mixer.close()

### Description
Closes the Mixer device.
```

--------------------------------

### Mixer.close()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Closes the Mixer device.

```APIDOC
## Mixer.close()

### Description
Closes the Mixer device.

### Method
POST

### Endpoint
/mixer/close
```

--------------------------------

### PCM.drain

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Plays residual buffered frames and stops the stream.

```APIDOC
## PCM.drain

### Description
For playback PCM objects, plays any remaining buffered audio frames and then stops the stream. In `PCM_NORMAL` mode, this call blocks until all pending playback is drained. Not very useful for capture PCM objects.

### Method
`drain()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (int) - The result of the operation.

### Response Example
```python
# Example: Drain the playback buffer
pcm.drain()
```
```

--------------------------------

### Set Mixer Control Volume

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Specify a numerical value as the parameter to mixertest.py to set the volume for a control. The value is a percentage applied to all channels.

```bash
$ ./mixertest.py Master 40


```

--------------------------------

### PCM.polldescriptors

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Returns file descriptors and event masks for polling.

```APIDOC
## PCM.polldescriptors

### Description
Returns a list of tuples, where each tuple contains a file descriptor and an event mask. These can be used with `select.poll` to wait for changes on the PCM stream.

### Method
`polldescriptors()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (list[tuple[int, int]]) - A list of (file descriptor, event mask) tuples.

### Response Example
```python
# Example: Get poll descriptors
descriptors = pcm.polldescriptors()
print(f"Poll descriptors: {descriptors}")
```
```

--------------------------------

### Mixer.getrec()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the current record mute status for each channel.

```APIDOC
## Mixer.getrec()

### Description
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.

### Method
GET

### Endpoint
/mixer/rec

### Response
#### Success Response (200)
- **record_status** (list[int]) - A list where each element is 0 (not recording) or 1 (recording) for the corresponding channel.
```

--------------------------------

### Set Volume

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Adjust the volume level for a mixer control. You can set the volume for a specific channel and specify the units.

```python
m.setvolume(volume)
```

--------------------------------

### PCM.pause

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Pauses or resumes the audio stream.

```APIDOC
## PCM.pause

### Description
Pauses or resumes the audio stream. If `enable` is `True`, the stream is paused. Otherwise, it is resumed.

### Method
`pause(enable: int = True)`

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
- **enable** (int) - Optional - Set to `True` to pause, `False` to resume. Defaults to `True`.

### Response
#### Success Response (200)
- **return_value** (int) - The result of the operation.

### Request Example
```python
# Example: Pause the stream
pcm.pause(True)

# Example: Resume the stream
pcm.pause(False)
```
```

--------------------------------

### Mixer.getmute()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Retrieves the current mute status for each channel of the mixer.

```APIDOC
## GET Mixer.getmute()

### Description
Returns 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.

### Response
#### Success Response (200)
- **list[int]** - A list of integers where 0 is unmuted and 1 is muted.
```

--------------------------------

### Mixer.setrec()

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Sets the capture mute flag for the mixer channels.

```APIDOC
## POST Mixer.setrec()

### Description
Sets the capture mute flag to a new value. This method will fail if the mixer has no capture switch capabilities.

### Parameters
#### Request Body
- **capture** (int) - Required - 0 for no capture, 1 for capture.
- **channel** (int) - Optional - The specific channel to change. Defaults to all channels.
```

--------------------------------

### Mixer.getmute()

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Retrieves the current mute status for each channel.

```APIDOC
## Mixer.getmute()

### Description
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.

### Method
GET

### Endpoint
/mixer/mute

### Response
#### Success Response (200)
- **mute_status** (list[int]) - A list where each element is 0 (not muted) or 1 (muted) for the corresponding channel.
```

--------------------------------

### PCM Polling and Timestamps

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Methods for handling poll descriptors and retrieving high-resolution timestamps.

```APIDOC
## PCM.polldescriptors()

### Description
Returns a list of (file descriptor, eventmask) tuples for use with select.poll.

## PCM.htimestamp()

### Description
Returns a tuple of (seconds, nanoseconds, frames_available_in_buffer).

### Response
- **tuple[int, int, int]** - High-resolution timestamp and buffer status.
```

--------------------------------

### PCM.drop

Source: http://larsimmisch.github.io/pyalsaaudio/_sources/libalsaaudio.rst.txt

Stops the stream and discards residual buffered frames.

```APIDOC
## PCM.drop

### Description
Stops the audio stream and discards any remaining buffered frames.

### Method
`drop()`

### Endpoint
N/A (Method call)

### Response
#### Success Response (200)
- **return_value** (int) - The result of the operation.

### Response Example
```python
# Example: Drop buffered frames
pcm.drop()
```
```

--------------------------------

### Set Enumerated Control

Source: http://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html

Set the currently selected item for an enumerated mixer control using its index.

```python
m.setenum(index)
```
Tokens:
Raw