Home
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running QNX Neutrino 7.1.
Audio & Graphics API
Audio Developer's Guide
The Audio Developer's Guide is intended for developers who want to write audio applications using the QNX Sound Architecture (QSA) drivers and library.
Audio Library
This chapter describes all of the supported QNX Sound Architecture (QSA) API functions, in alphabetical order; undocumented calls aren't supported.
snd_pcm_chmap_query_t
Entry in an array of channel maps

QNX Momentics IDE User's Guide
This User's Guide describes version 7.1 of the Integrated Development Environment (IDE) that's part of the QNX Momentics tool suite.
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running QNX Neutrino 7.1.
- Quickstart Guide
- OS Components & Operations
- Audio & Graphics API
  - Audio Developer's Guide
    The Audio Developer's Guide is intended for developers who want to write audio applications using the QNX Sound Architecture (QSA) drivers and library.
    - Audio Architecture
      This chapter includes information about QNX Sound Architecture (QSA), sounds cards and devices, sound card control devices, mixers, and pulse code modulation (PCM).
    - Playing and Capturing Audio Data
      This chapter describes the major steps required to play back and capture (i.e., record) sound data.
    - Mixer Architecture
      This section describes the mixer architecture.
    - Audio Concurrency Management
      You can manage multiple audio streams using various audio policies.
    - Optimizing Audio
      Here are some tips for reducing audio latency:
    - Audio Library
      This chapter describes all of the supported QNX Sound Architecture (QSA) API functions, in alphabetical order; undocumented calls aren't supported.
      - snd_afm_close()
        Close an AFM handle and free its resources
      - snd_afm_file_descriptor()
        Return the file descriptor of the connection to the AFM interface
      - snd_afm_get_ap_data()
        Retrieve data from the acoustic library in an AFM
      - snd_afm_get_audio_mode()
        Get the currently applied audio mode
      - snd_afm_get_param()
        Get a configuration parameter for the specified AFM
      - snd_afm_get_vin_list()
        Get the current Vehicle Input (VIN) list from an AFM
      - snd_afm_get_vin_list_count()
        Get the number of Vehicle Input (VIN) items required by an AFM's VIN list
      - snd_afm_info()
        Get the setup information for an AFM
      - snd_afm_info_t
        Setup information about an AFM
      - snd_afm_load_ap_dataset()
        Load an acoustic processing data set into a running AFM
      - snd_afm_open()
        Create a handle and open a connection to a specified AMP Functional Module (AFM)
      - snd_afm_open_name()
        Create a handle and open a connection to an AMP functional module specified by name
      - snd_afm_set_ap_data()
        Set data within the acoustic library in an AFM
      - snd_afm_set_audio_mode()
        Set the audio mode used to tune acoustic processing parameters
      - snd_afm_set_param()
        Set a configuration parameter for the specified AFM
      - snd_afm_set_vin_stream()
        Set the current Vehicle Input (VIN) data for an AFM.
      - snd_afm_start()
        Start AFM processing
      - snd_afm_status()
        Get the current status of an AFM
      - snd_afm_status_t
        The status of an AFM
      - snd_afm_stop()
        Stop AFM processing
      - snd_card_get_longname()
        Find the long name for a given card number
      - snd_card_get_name()
        Find the name for a given card number
      - snd_card_name()
        Find the card number for a given name
      - snd_cards()
        Count the sound cards
      - snd_cards_list()
        Count the sound cards and list their card numbers in an array
      - snd_ctl_callbacks_t
        Control callback functions
      - snd_ctl_close()
        Close a control handle
      - snd_ctl_file_descriptor()
        Get the control file descriptor
      - snd_ctl_ducking_read()
        Get the audio streams that are active
      - snd_ctl_ducking_status_read()
        Get all active audio subchannels associated with an audio ducking output
      - snd_ctl_get_filter()
        Get the current control events filter
      - snd_ctl_hw_info()
        Get information about a sound card's hardware
      - snd_ctl_hw_info_t
        Information about a sound card's hardware
      - snd_ctl_mixer_switch_list()
        Get the number and names of control switches for the mixer
      - snd_ctl_mixer_switch_read()
        Get a mixer switch setting
      - snd_ctl_mixer_switch_write()
        Adjust a mixer switch setting
      - snd_ctl_open()
        Create a connection and handle to the specified control device
      - snd_ctl_pcm_channel_info()
        Get information about a PCM channel's capabilities from a control handle
      - snd_ctl_pcm_info()
        Get general information about a PCM device from a control handle
      - snd_ctl_read()
        Read pending control events
      - snd_ctl_set_filter()
        Set the control events filter
      - snd_ducking_status_t
        Information about the audio types that are active in terms of audio concurrency management policies in effect on the system
      - snd_ducking_type_status_t
        Information about the active audio type.
      - snd_mixer_callbacks_t
        List of mixer callback functions
      - snd_mixer_close()
        Close a mixer handle
      - snd_mixer_eid_t
        Mixer element ID structure
      - snd_mixer_element_info()
        Get information about a mixer element
      - snd_mixer_element_info_build()
        Get information about a mixer element and allocate required buffering
      - snd_mixer_element_info_free()
        Free memory allocated by snd_mixer_element_info_build() for the specified element
      - snd_mixer_element_info_t
        Mixer element information structure
      - snd_mixer_element_read()
        Get a mixer element's configurable parameters
      - snd_mixer_element_t
        Mixer element control structure
      - snd_mixer_element_write()
        Set a mixer element's configurable parameters
      - snd_mixer_elements()
        Get the number of elements in the mixer and their element IDs
      - snd_mixer_elements_t
        Information about all elements in a mixer
      - snd_mixer_element_volume1_range_t
        Mixer minimum
      - snd_mixer_file_descriptor()
        Return the file descriptor of the connection to the sound mixer interface
      - snd_mixer_filter_t
        Information about a mixer's filters
      - snd_mixer_get_bit()
        Return the boolean value of a single bit in the specified bitmap
      - snd_mixer_get_filter()
        Get the current mask of mixer events that the driver is tracking
      - snd_mixer_gid_t
        Mixer group ID structure
      - snd_mixer_group_read()
        Get a mixer group's configurable parameters
      - snd_mixer_group_t
        Mixer group control structure
      - snd_mixer_group_write()
        Set a mixer group's configurable parameters
      - snd_mixer_groups()
        Get the number of groups in the mixer and their group IDs
      - snd_mixer_groups_t
        Information about all of the mixer groups
      - snd_mixer_info()
        Get general information about a mixer device
      - snd_mixer_info_t
        Information about a mixer
      - snd_mixer_open()
        Create a connection and handle to a specified mixer device
      - snd_mixer_open_name()
        Create a connection and handle to a mixer device specified by name
      - snd_mixer_read()
        Read pending mixer events
      - snd_mixer_routes()
        Get the number of routes in the mixer and their IDs
      - snd_mixer_routes_t
        Information about mixer routes
      - snd_mixer_set_bit()
        Set the boolean value of a single bit in the specified bitmap
      - snd_mixer_set_filter()
        Set the mask of mixer events that the driver will track
      - snd_mixer_sort_eid_table()
        Sort a list of element ID structures
      - snd_mixer_sort_gid_table()
        Sort a list of group ID structures
      - snd_mixer_weight_entry_t
        Weight table for sorting mixer element and group IDs
      - snd_pcm_build_linear_format()
        Encode a linear format value
      - snd_pcm_capture_go()
        Start a PCM capture channel running
      - snd_pcm_capture_pause()
        Pause a channel that's capturing
      - snd_pcm_capture_prepare()
        Signal the driver to ready the capture channel
      - snd_pcm_capture_resume()
        Resume a channel that was paused while capturing
      - snd_pcm_channel_audio_ducking()
        Enable or disable audio ducking
      - snd_pcm_channel_drain()
        Block until buffered data is fully consumed and then stop the stream (playback) or stop the stream immediately but preserve the buffered data (capture)
      - snd_pcm_channel_drop()
        Stop playback or capture immediately and discard buffered data
      - snd_pcm_channel_go()
        Start a PCM channel running
      - snd_pcm_channel_info()
        Get information about a PCM channel's current capabilities
      - snd_pcm_channel_info_t
        Information structure for a PCM channel
      - snd_pcm_channel_params()
        Set a PCM channel's configurable parameters
      - snd_pcm_channel_params_t
        PCM channel parameters
      - snd_pcm_channel_pause()
        Pause a channel
      - snd_pcm_channel_prepare()
        Signal the driver to ready the specified channel
      - snd_pcm_channel_read_event()
        Get a PCM event
      - snd_pcm_channel_resume()
        Resume a channel
      - snd_pcm_channel_setup()
        Get the current configuration for the specified PCM channel
      - snd_pcm_channel_setup_t
        Current configuration of a PCM channel
      - snd_pcm_channel_status()
        Get the runtime status of a PCM channel
      - snd_pcm_channel_status_t
        PCM channel status structure
      - snd_pcm_chmap_query_t
        Entry in an array of channel maps
      - snd_pcm_chmap_t
        Information about a channel map
      - snd_pcm_close()
        Close a PCM handle and free its resources
      - snd_pcm_event_t
        Information about the PCM event that occurred
      - snd_pcm_file_descriptor()
        Return the file descriptor of the connection to the PCM interface
      - snd_pcm_filter_t
        The PCM Events to filter
      - snd_pcm_find()
        Find all PCM devices in the system that meet the given criteria
      - snd_pcm_format_big_endian()
        Check for a big-endian format
      - snd_pcm_format_linear()
        Check for a linear format
      - snd_pcm_format_little_endian()
        Check for a little-endian format
      - snd_pcm_format_signed()
        Check for a signed format
      - snd_pcm_format_size()
        Convert the size in the given samples to bytes
      - snd_pcm_format_t
        PCM data format structure
      - snd_pcm_format_unsigned()
        Check for an unsigned format
      - snd_pcm_format_width()
        Return the sample width in bits for a format
      - snd_pcm_free_chmaps()
        Free a list of channel mappings
      - snd_pcm_get_apx_data()
        Retrieve data from the acoustic library in an APX module
      - snd_pcm_get_chmap()
        Get the current channel mapping, accounting for voice conversion on the capture path
      - snd_pcm_get_filter()
        Retrieves the PCM filters that your application is subscribed to.
      - snd_pcm_get_format_name()
        Convert a format value into a human-readable text string
      - snd_pcm_info()
        Get general information about a PCM device
      - snd_pcm_info_t
        Capability information about a PCM device
      - snd_pcm_link()
        Link two PCM streams together
      - snd_pcm_link_mode()
        Set the link mode for a subchannel in a group
      - snd_pcm_link_transition ()
        Indicate to the specified PCM handle to trigger other handles in the group to start playback as soon as the specified audio subchannel's currently buffered data has been completely written to the hardware.
      - snd_pcm_load_apx_dataset()
        Load an acoustic processing dataset into a running APX module
      - snd_pcm_mute_event_t
        Information about the mute event
      - snd_pcm_nonblock_mode()
        Set or reset the blocking behavior of reads and writes to PCM channels
      - snd_pcm_open()
        Create a handle and open a connection to a specified audio interface
      - snd_pcm_open_name()
        Create a handle and open a connection to an audio interface specified by name
      - snd_pcm_open_preferred()
        Create a handle and open a connection to the preferred audio interface
      - snd_pcm_outputclass_event_t
        Information about the output port.
      - snd_pcm_playback_go()
        Start a PCM playback channel running
      - snd_pcm_playback_pause()
        Pause a channel that's playing back
      - snd_pcm_playback_prepare()
        Signal the driver to ready the playback channel
      - snd_pcm_playback_resume()
        Resume a channel that was paused while playing back
      - snd_pcm_plugin_drain()
        Block until buffered data is fully consumed and then stop the stream (playback) or stop the stream immediately but preserve the buffered data (capture) (plugin-aware)
      - snd_pcm_plugin_drop()
        Stop playback or capture immediately and discard buffered data (plugin-aware)
      - snd_pcm_plugin_get_voice_conversion()
        Get the current voice conversion structure for a channel
      - snd_pcm_plugin_info()
        Get information about a PCM channel's capabilities (plugin-aware)
      - snd_pcm_plugin_params()
        Set the configurable parameters for a PCM channel (plugin-aware)
      - snd_pcm_plugin_prepare()
        Signal the driver to ready the specified channel (plugin-aware)
      - snd_pcm_plugin_reset_voice_conversion()
        Resets the parameters of the voice conversion
      - snd_pcm_plugin_read()
        Transfer PCM data from the capture channel (plugin-aware)
      - snd_pcm_plugin_set_disable()
        Disable PCM plugins
      - snd_pcm_plugin_set_enable()
        Enable PCM plugins
      - snd_pcm_plugin_set_src_method()
        Set the system's source filter method (plugin-aware)
      - snd_pcm_plugin_set_src_mode()
        Set the system's source mode (plugin-aware)
      - snd_pcm_plugin_set_voice_conversion()
        Set the current voice conversion structure for a channel
      - snd_pcm_plugin_setup()
        Get the current configuration for the specified PCM channel (plugin aware)
      - snd_pcm_plugin_status()
        Get the runtime status of a PCM channel (plugin aware)
      - snd_pcm_plugin_update_src()
        Get the size of the next fragment to write (plugin-aware)
      - snd_pcm_plugin_write()
        Transfer PCM data to playback channel (plugin-aware)
      - snd_pcm_query_channel_map()
        Get the current channel mapping for a PCM stream
      - snd_pcm_query_chmaps()
        Get a list of the available channel mappings for a PCM stream
      - snd_pcm_read()
        Transfer PCM data from the capture channel
      - snd_pcm_set_apx_data()
        Set data within the acoustic library in an APX module
      - snd_pcm_set_apx_external_volume()
        Load volume controls external to io-audio
      - snd_pcm_set_apx_user_volume()
        Load the user-intended volume
      - snd_pcm_set_chmap()
        Set the current channel mapping for a PCM stream
      - snd_pcm_set_filter()
        Enable or disable the generation of PCM events
      - snd_pcm_set_output_class()
        Set the current audio output port information.
      - snd_pcm_status_event_t
        Information about status change because audio concurrency management occurred on the audio stream
      - snd_pcm_t
        The handle for the PCM device.
      - snd_pcm_unlink()
        Detach a PCM stream from a link group
      - snd_pcm_voice_conversion_t
        Data structure that controls voice conversion
      - snd_pcm_write()
        Transfer PCM data to playback channel
      - snd_strerror()
        Convert an error code to a string
      - snd_switch_t
        Information about a mixer's switch
    - afm_ctl.c example
      This is the source for the afm_ctl utility.
    - apx_ctl.c example
      This is the source for the apx_ctl utility.
    - wave.c example
      This is a sample application that plays back audio data.
    - waverec.c example
      This is a sample application that captures (i.e., records) audio data.
    - mix_ctl.c example
      This is a sample application that captures the groups and switches in the mixer.
    - audiomgmt_monitor.c example
      This is a sample application shows how to get the current active audio types.
    - ALSA and libasound.so
      The only supported interface to the ALSA 5 drivers is through libasound.so. Direct use of ioctl() commands isn't supported because of the requirements of the ALSA API. It uses ioctl() commands in ways that are illegal in the QNX Neutrino RTOS (e.g., passing a structure that contains a pointer through an ioctl()).
    - Glossary
  - Gestures Library Reference
    The Gestures library provides gesture recognizers to detect gestures through touch events that occur when you place one or more fingers on a touch screen.
  - Image Library Reference
  - Input Events Library Reference
    The Input Events library provides the framework necessary for Screen Graphics Subsystem to communicate with your touch driver.
  - OpenWF Configuration Developer's Guide
    If you are integrating a new display, you must configure and provide the parameters of your display based on its specifications via the OpenWF Display Configuration API (Wfdcfg Library).
  - Screen Graphics Subsystem Developer's Guide
    QNX Screen Graphics Subsystem is a graphics framework that provides all the functionality necessary to develop interactive user experiences.
  - Video Capture Developer's Guide
    The video capture framework provides applications the ability to capture frames from a video input source. These frames can be passed to a graphics component such as Screen for display.
- Multimedia
- Networking Middleware
- Programming
- Sensor Framework
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX Neutrino RTOS system and developers who want to create a QNX Neutrino resource manager free from vulnerabilities.
- Utilities & Libraries
QNX Hypervisor
The QNX Hypervisor allows you to run multiple OSs on a target system so you can separate critical and non-critical functions, support a wide variety of applications, and reduce hardware costs.
QNX Software in the Cloud
QNX Software in the Cloud enables developers to use the QNX software in Amazon Web Services (AWS) and Microsoft Azure (Azure).
QNX Advanced Virtualization Frameworks User's Guide
This User's Guide is aimed at all systems integrators and developers who want to design and build embedded systems using the QNX Advanced Virtualization Frameworks.
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation and explains how to obtain technical support.

snd_pcm_chmap_query_t

Entry in an array of channel maps

Synopsis:

#include <sys/asound.h>

typedef struct snd_pcm_chmap_query {
        enum snd_pcm_chmap_type type;
        snd_pcm_chmap_t map;
} snd_pcm_chmap_query_t;

Description:

The snd_pcm_chmap_query_t structure describes a channel map. It's used as the entries in an array returned by snd_pcm_query_chmaps(). The members include:

type

The type of the channel map; one of the following:

SND_CHMAP_TYPE_NONE — unspecified channel position
SND_CHMAP_TYPE_FIXED — fixed channel position
SND_CHMAP_TYPE_VAR — freely swappable channel position
SND_CHMAP_TYPE_PAIRED — pair-wise swappable channel position

map

A pointer to a snd_pcm_chmap_t structure that describes the channel map.

Classification:

QNX Neutrino

Page updated: March 12, 2026