alsa.c File Reference

#include <alloca.h>
#include <alsa/asoundlib.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include "alsa_common.h"
#include "audio/audio_playback.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "tv.h"
#include "types.h"
#include "utils/color_out.h"
#include "utils/audio_buffer.h"

Include dependency graph for alsa.c:

Go to the source code of this file.

Classes
struct	state_alsa_playback

Macros
#define	BUF_LEN_DEFAULT_MS   60
#define	BUF_LEN_DEFAULT_SYNC_MS   200
#define	CHECK_OK(cmd)
#define	EXIT_IF_FAILED(cmd, name)
#define	MOD_NAME   "[ALSA play.] "
#define	SCRATCHPAD_SIZE   (1024*1024)

Enumerations
enum	playback_mode_t { THREAD = 0 , SYNC , ASYNC }

Functions
	ADD_TO_PARAM ("alsa-play-period-size", "* alsa-play-period-size=<frames>\n" " ALSA playback period size in frames (default is device minimum) .\n")
	ADD_TO_PARAM ("alsa-playback-api", "* alsa-playback-api={thread|sync|async}\n" " ALSA API.\n")
	ADD_TO_PARAM ("alsa-playback-buffer", "* alsa-playback-buffer=<len>\n" " Buffer length. Can be used to balance robustness and latency, in microseconds.\n")
static void	alsa_play_async_callback (snd_async_handler_t *handler)
static bool	audio_play_alsa_ctl (void *state, int request, void *data, size_t *len)
static void	audio_play_alsa_done (void *state)
static void	audio_play_alsa_help (void)
static void *	audio_play_alsa_init (const char *cfg)
static void	audio_play_alsa_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static void	audio_play_alsa_put_frame (void *state, const struct audio_frame *frame)
static bool	audio_play_alsa_query_format (struct state_alsa_playback *s, void *data, size_t *len)
static bool	audio_play_alsa_reconfigure (void *state, struct audio_desc desc)
static void	audio_play_alsa_write_frame (void *state, const struct audio_frame *frame)
static long	get_sched_latency_ns (void)
static snd_config_t *	init_local_config_with_workaround (char const *pcm_node_name)
static bool	is_default_pulse (void)
	REGISTER_MODULE (alsa, &aplay_alsa_info, LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION)
static void	set_device_buffer (snd_pcm_t *handle, playback_mode_t playback_mode, snd_pcm_hw_params_t *params)
static void *	worker (void *args)
static void	write_fill (struct state_alsa_playback *s)
static int	write_samples (snd_pcm_t *handle, const char *data, int bps, int ch_count, int frames, bool noninterleaved, playback_mode_t playback_mode, char *tmp_buffer)

Variables
static const struct audio_playback_info	aplay_alsa_info

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file alsa.c.

Macro Definition Documentation

BUF_LEN_DEFAULT_MS

#define BUF_LEN_DEFAULT_MS   60

Definition at line 72 of file alsa.c.

Referenced by set_device_buffer().

BUF_LEN_DEFAULT_SYNC_MS

#define BUF_LEN_DEFAULT_SYNC_MS   200

Definition at line 73 of file alsa.c.

Referenced by set_device_buffer().

CHECK_OK

#define CHECK_OK

(

cmd

)

Value:

        do {\
                int rc = cmd;\
                if (rc < 0) {;\
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", #cmd, snd_strerror(rc));\
                }\
        } while (0)

Definition at line 98 of file alsa.c.

#define CHECK_OK(cmd) \
        do {\
                int rc = cmd;\
                if (rc < 0) {;\
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", #cmd, snd_strerror(rc));\
                }\
        } while (0)

Referenced by audio_play_alsa_reconfigure(), and set_device_buffer().

EXIT_IF_FAILED

#define EXIT_IF_FAILED	(		cmd,
			name )

Value:

        do {\
                int rc = cmd;\
                if (rc < 0) {;\
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", name, snd_strerror(rc));\
                        goto error;\
                }\
        } while (0)

Speex jitter buffer use is currently not stable and not ready for production use. Moreover, it is unclear whether is suitable for our use case.

Definition at line 89 of file alsa.c.

#define EXIT_IF_FAILED(cmd, name) \
        do {\
                int rc = cmd;\
                if (rc < 0) {;\
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", name, snd_strerror(rc));\
                        goto error;\
                }\
        } while (0)

Referenced by audio_play_alsa_reconfigure().

MOD_NAME

#define MOD_NAME   "[ALSA play.] "

Definition at line 74 of file alsa.c.

SCRATCHPAD_SIZE

#define SCRATCHPAD_SIZE   (1024*1024)

Definition at line 75 of file alsa.c.

Referenced by audio_play_alsa_init(), and write_samples().

Enumeration Type Documentation

playback_mode_t

enum playback_mode_t

Enumerator
THREAD
SYNC
ASYNC

Definition at line 106 of file alsa.c.

             {
        THREAD = 0,
        SYNC,
        ASYNC
} playback_mode_t;

Function Documentation

ADD_TO_PARAM() [1/3]

ADD_TO_PARAM

(

"alsa-play-period-size"

)

ADD_TO_PARAM() [2/3]

ADD_TO_PARAM

(

"alsa-playback-api"

)

ADD_TO_PARAM() [3/3]

ADD_TO_PARAM	(	"alsa-playback-buffer"	,
		"* alsa-playback-	buffer = <len>\n" "  Buffer length. Can be used to balance robustness and latency,
		in microseconds.\n"	)

alsa_play_async_callback()

static void alsa_play_async_callback ( snd_async_handler_t * handler )

static

Definition at line 396 of file alsa.c.

                                                                   {
        struct state_alsa_playback *s =
                snd_async_handler_get_callback_private(handler);
 
        struct audio_frame f = { .bps = s->desc.bps,
                .sample_rate = s->desc.sample_rate,
                .ch_count = s->desc.ch_count };
 
        size_t len = f.bps * f.ch_count * s->period_size;
 
        char *data = malloc(len);
 
        pthread_mutex_lock(&s->lock);
 
        snd_pcm_sframes_t avail;
        avail = snd_pcm_avail_update(s->handle);
        while (avail >= (snd_pcm_sframes_t) s->period_size)
        {
                int ret;
                ret = audio_buffer_read(s->buf, data, len);
                memset(data + ret, 0, len - ret);
                f.data = data;
                f.data_len = len;
                audio_play_alsa_write_frame(s, &f);
                avail = snd_pcm_avail_update(s->handle);
        }
 
        free(data);
 
        pthread_mutex_unlock(&s->lock);
}

References audio_buffer_read(), audio_play_alsa_write_frame(), audio_desc::bps, audio_frame::bps, state_alsa_playback::buf, audio_desc::ch_count, audio_frame::ch_count, audio_frame::data, audio_frame::data_len, state_alsa_playback::desc, state_alsa_playback::handle, len, state_alsa_playback::lock, state_alsa_playback::period_size, and audio_desc::sample_rate.

Referenced by audio_play_alsa_reconfigure().

Here is the call graph for this function:

audio_play_alsa_ctl()

static bool audio_play_alsa_ctl ( void * state, int request, void * data, size_t * len )

static

Definition at line 383 of file alsa.c.

{
        struct state_alsa_playback *s = (struct state_alsa_playback *) state;
 
        switch (request) {
        case AUDIO_PLAYBACK_CTL_QUERY_FORMAT:
                return audio_play_alsa_query_format(s, data, len);
        default:
                return false;
        }
 
}

References audio_play_alsa_query_format(), AUDIO_PLAYBACK_CTL_QUERY_FORMAT, len, and state.

Referenced by audio_play_alsa_init().

Here is the call graph for this function:

audio_play_alsa_done()

static void audio_play_alsa_done ( void * state )

static

Definition at line 1064 of file alsa.c.

{
        struct state_alsa_playback *s = (struct state_alsa_playback *) state;
 
        if (s->playback_mode == THREAD && s->thread_started) {
                pthread_mutex_lock(&s->lock);
                s->should_exit_thread = true;
                pthread_mutex_unlock(&s->lock);
                pthread_join(s->thread_id, NULL);
        }
 
        if (s->playback_mode == ASYNC && s->pcm_callback) {
                snd_async_del_handler(s->pcm_callback);
        }
 
        snd_pcm_drain(s->handle);
        snd_pcm_close(s->handle);
        if (s->local_config) {
                snd_config_delete(s->local_config);
        }
        if (s->buf != NULL) {
#ifdef USE_SPEEX_JITTER_BUFFER
                jitter_buffer_destroy(s->buf);
#else
                audio_buffer_destroy(s->buf);
#endif
        }
 
        pthread_mutex_destroy(&s->lock);
 
        free(s->scratchpad);
        free(s);
}

References ASYNC, audio_buffer_destroy(), state_alsa_playback::buf, state_alsa_playback::handle, state_alsa_playback::local_config, state_alsa_playback::lock, state_alsa_playback::pcm_callback, state_alsa_playback::playback_mode, state_alsa_playback::scratchpad, state_alsa_playback::should_exit_thread, state, THREAD, state_alsa_playback::thread_id, and state_alsa_playback::thread_started.

Here is the call graph for this function:

audio_play_alsa_help()

static void audio_play_alsa_help ( void )

static

Definition at line 706 of file alsa.c.

                                       {
        printf("Usage\n");
        color_printf(TERM_BOLD TERM_FG_RED "\t-r alsa" TERM_FG_RESET "[:<device>] --param alsa-playback-api={thread|async|sync}[,alsa-playback-buffer=[<us>-]<us>][,audio-buffer-len=<ablen>]\n" TERM_RESET);
        color_printf("where\n");
        color_printf(TERM_BOLD "\talsa-playback-api={thread|async|sync}\n" TERM_RESET);
        color_printf("\t\tuse selected API ('thread' is default)\n");
        color_printf(TERM_BOLD "\talsa-playback-buffer=[<us>-]<us>\n" TERM_RESET);
        color_printf("\t\tset buffer max and optionally max (thread and async API only)\n");
        color_printf(TERM_BOLD "\taudio-buffer-len=<ablen>\n" TERM_RESET);
        color_printf("\t\tlength of UG internal ALSA buffer (in milliseconds)\n");
        printf("\n");
 
        printf("Available ALSA playback devices:\n");
        audio_alsa_list_devices();
}

References audio_alsa_list_devices(), color_printf(), TERM_BOLD, TERM_FG_RED, TERM_FG_RESET, and TERM_RESET.

Referenced by audio_play_alsa_init().

Here is the call graph for this function:

audio_play_alsa_init()

static void * audio_play_alsa_init ( const char * cfg )

static

Definition at line 837 of file alsa.c.

{
        int rc;
        const char *name;
 
        struct state_alsa_playback *s = calloc(1, sizeof(struct state_alsa_playback));
 
        long latency_ns = get_sched_latency_ns();
        if (latency_ns > 0) {
                s->sched_latency_ms = latency_ns / 1000 / 1000;
                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Sched latency: %ld ms.\n", s->sched_latency_ms);
        } else {
                s->sched_latency_ms = 24;
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Unable to get latency, assuming %ld.\n", s->sched_latency_ms);
        }
 
        const char *use_api;
        use_api = get_commandline_param("alsa-playback-api");
        if (use_api) {
                if (strcmp(use_api, "thread") == 0 || strcmp(use_api, "new") == 0) {
                        s->playback_mode = THREAD;
                } else if (strcmp(use_api, "sync") == 0 || strcmp(use_api, "old") == 0) {
                        s->playback_mode = SYNC;
                } else if (strcmp(use_api, "async") == 0) {
                        s->playback_mode = ASYNC;
                } else {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unknown API string \"%s\"!\n", use_api);
                        free(s);
                        return NULL;
                }
        }
 
        if (s->playback_mode == THREAD) {
                log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Using new API. In case of problems, you may try to use '--param alsa-playback-api=sync'.\n");
        }
 
        if (s->playback_mode == ASYNC) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Async API is experimental, in case of problems use either \"thread\" or \"sync\" API\n");
        }
 
        if (strlen(cfg) > 0) {
                if(strcmp(cfg, "help") == 0) {
                        audio_play_alsa_help();
                        free(s);
                        return INIT_NOERR;
                }
                name = cfg;
        } else {
                if (is_default_pulse()) {
                        name = "pulse";
                } else {
                        name = "default";
                }
        }
 
        char device[1024] = "pcm.";
 
        strncat(device, name, sizeof(device) - strlen(device) - 1);
 
        if (s->playback_mode == SYNC) {
                s->local_config = init_local_config_with_workaround(device);
        }
 
        if (s->playback_mode == SYNC && s->local_config) {
                rc = snd_pcm_open_lconf(&s->handle, name,
                                SND_PCM_STREAM_PLAYBACK, 0, s->local_config);
        } else {
                rc = snd_pcm_open(&s->handle, name,
                                SND_PCM_STREAM_PLAYBACK, 0);
        }
 
        if (rc < 0) {
                    log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to open pcm device: %s\n",
                                    snd_strerror(rc));
                    goto error;
        }
        print_alsa_device_info(s->handle, MOD_NAME);
 
        pthread_mutex_init(&s->lock, NULL);
        if (s->playback_mode == THREAD) {
#ifdef USE_SPEEX_JITTER_BUFFER
                s->buf = jitter_buffer_init(1);
#endif
        } else if (s->playback_mode == SYNC) {
                rc = snd_pcm_nonblock(s->handle, 1);
                if(rc < 0) {
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: Unable to set nonblock mode.\n");
                }
        }
 
        /* CC3000e playback needs to be initialized prior to capture
         * (to arbitrary value) in order to work. This hack ensures
         * that. */
        if (snd_pcm_name(s->handle) && strstr(snd_pcm_name(s->handle), "CARD=Speakerph")) {
                struct audio_desc desc = {2, 48000, 1, AC_PCM};
                size_t len = sizeof desc;
                if (audio_play_alsa_ctl(s, AUDIO_PLAYBACK_CTL_QUERY_FORMAT, &desc, &len)) {
                        audio_play_alsa_reconfigure(s, desc);
                }
        }
 
        s->scratchpad = malloc(SCRATCHPAD_SIZE);
        return s;
 
error:
        free(s);
        return NULL;
}

References AC_PCM, ASYNC, audio_play_alsa_ctl(), audio_play_alsa_help(), audio_play_alsa_reconfigure(), AUDIO_PLAYBACK_CTL_QUERY_FORMAT, state_alsa_playback::buf, desc, get_commandline_param(), get_sched_latency_ns(), state_alsa_playback::handle, init_local_config_with_workaround(), INIT_NOERR, is_default_pulse(), len, state_alsa_playback::local_config, state_alsa_playback::lock, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, name, state_alsa_playback::playback_mode, print_alsa_device_info(), state_alsa_playback::sched_latency_ms, state_alsa_playback::scratchpad, SCRATCHPAD_SIZE, SYNC, and THREAD.

Here is the call graph for this function:

audio_play_alsa_probe()

static void audio_play_alsa_probe ( struct device_info ** available_devices, int * count, void(** deleter )(void *) )

static

Definition at line 697 of file alsa.c.

{
        *deleter = free;
        const char *whitelist[] = {"pulse", "dmix"};
        audio_alsa_probe(available_devices, count, whitelist, sizeof(whitelist) / sizeof(*whitelist));
        strcpy((*available_devices)[0].dev, "");
        strcpy((*available_devices)[0].name, "Default Linux audio output");
}

References audio_alsa_probe(), count, deleter, and name.

Here is the call graph for this function:

audio_play_alsa_put_frame()

static void audio_play_alsa_put_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 1029 of file alsa.c.

{
        struct state_alsa_playback *s = state;
 
        // first repair asyn stream if needed
        if (s->playback_mode == ASYNC && snd_pcm_state(s->handle) != SND_PCM_STATE_RUNNING) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "%s\n", alsa_get_pcm_state_name(snd_pcm_state(s->handle)));
                snd_pcm_prepare(s->handle);
                write_fill(s);
                int err = snd_pcm_start(s->handle);
                if (err < 0) {
                        printf("Start error: %s\n", snd_strerror(err));
                }
                log_msg(LOG_LEVEL_NOTICE, MOD_NAME "%s\n", alsa_get_pcm_state_name(snd_pcm_state(s->handle)));
        }
 
        if (s->playback_mode == THREAD || s->playback_mode == ASYNC) {
               pthread_mutex_lock(&s->lock);
#ifdef USE_SPEEX_JITTER_BUFFER
                JitterBufferPacket pkt;
                pkt.data = frame->data;
                pkt.len = frame->data_len;
                pkt.timestamp = s->timestamp;
                pkt.span = frame->data_len / s->desc.bps / s->desc.ch_count;
                s->timestamp += pkt.span;
                jitter_buffer_put(s->buf, &pkt);
#else
                audio_buffer_write(s->buf, frame->data, frame->data_len);
#endif
                pthread_mutex_unlock(&s->lock);
        } else {
                audio_play_alsa_write_frame(state, frame);
        }
}

References alsa_get_pcm_state_name(), ASYNC, audio_buffer_write(), audio_play_alsa_write_frame(), audio_desc::bps, state_alsa_playback::buf, audio_desc::ch_count, state_alsa_playback::desc, frame, state_alsa_playback::handle, state_alsa_playback::lock, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, log_msg(), MOD_NAME, state_alsa_playback::playback_mode, state, THREAD, state_alsa_playback::timestamp, video_frame::timestamp, and write_fill().

Here is the call graph for this function:

audio_play_alsa_query_format()

static bool audio_play_alsa_query_format ( struct state_alsa_playback * s, void * data, size_t * len )

static

Definition at line 261 of file alsa.c.

{
        struct audio_desc desc;
        if (*len < sizeof desc) {
                return false;
        } else {
                memcpy(&desc, data, sizeof desc);
        }
 
        int rc;
        unsigned int val;
        int dir;
        snd_pcm_hw_params_t *params;
        struct audio_desc ret;
 
        memset(&ret, 0, sizeof ret);
 
        ret.codec = AC_PCM;
 
        snd_pcm_hw_params_alloca(&params);
 
        /* Fill it in with default values. */
        rc = snd_pcm_hw_params_any(s->handle, params);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to set default parameters: %s\n",
                        snd_strerror(rc));
                return false;
        }
 
        assert (desc.bps > 0 && desc.bps <= 4);
        int bps = desc.bps;
        for ( ; ; ) {
                if (!snd_pcm_hw_params_test_format(s->handle, params, bps_to_snd_fmts[bps])) {
                        break;
                }
                // We try to find nearest higher
                if (bps >= desc.bps) {
                        bps++;
                } else { // or nearest lower
                        bps--;
                }
                if (bps > 4) {
                        bps = desc.bps - 1;
                }
                if (bps == 0) {
                        break;
                }
        }
 
        ret.bps = bps;
 
        rc = snd_pcm_hw_params_set_format(s->handle, params, bps_to_snd_fmts[bps]);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to set capture format: %s\n",
                                snd_strerror(rc));
                return false;
        }
 
        ret.sample_rate = get_rate_near(s->handle, params, desc.sample_rate);
        if (!ret.sample_rate) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to find sample rate:\n");
                return false;
        }
 
        /* set sampling rate */
        val = ret.sample_rate;
        dir = 0;
        rc = snd_pcm_hw_params_set_rate_near(s->handle, params,
                &val, &dir);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to set sampling rate (%s %d): %s\n",
                        dir == 0 ? "=" : (dir == -1 ? "<" : ">"),
                        val, snd_strerror(rc));
                return false;
        }
 
        unsigned int max_channels;
        rc = snd_pcm_hw_params_get_channels_max(params, &max_channels);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to get max number of channels!\n");
                return false;
        }
        int channels = desc.ch_count;
        // We try to find nearest higher
        for ( ; channels <= (int) max_channels; ++channels) {
                if (!snd_pcm_hw_params_test_channels(s->handle, params, channels)) {
                        break;
                }
        }
        if (channels > (int) max_channels) { // or nearest lower
                for (channels = desc.ch_count - 1; channels > 0; --channels) {
                        if (!snd_pcm_hw_params_test_channels(s->handle, params, channels)) {
                                break;
                        }
                }
        }
 
        if (channels == 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to get usable channel configuration (max channels: %u)!\n", max_channels);
                return false;
        }
 
        rc = snd_pcm_hw_params_set_channels(s->handle, params, channels);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to set channels!\n");
                return false;
        }
 
        ret.ch_count = channels;
 
        if (snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_INTERLEAVED)
                && snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
 
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot find supported access mode!\n");
                return false;
        }
 
        memcpy(data, &ret, sizeof ret);
        *len = sizeof ret;
        return true;
}

References AC_PCM, audio_desc::bps, bps_to_snd_fmts, audio_desc::ch_count, channels, audio_desc::codec, desc, get_rate_near(), state_alsa_playback::handle, len, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, params, audio_desc::sample_rate, and val.

Referenced by audio_play_alsa_ctl().

Here is the call graph for this function:

audio_play_alsa_reconfigure()

static bool audio_play_alsa_reconfigure ( void * state, struct audio_desc desc )

static

Todo

Consider using snd_pcm_hw_params_set_buffer_time_first() by default, it works fine with PulseAudio. However, may underrun with different drivers/devices (Juli@?) where the buffer size is significantly lower.

Definition at line 496 of file alsa.c.

{
        struct state_alsa_playback *s = (struct state_alsa_playback *) state;
        snd_pcm_hw_params_t *params;
        snd_pcm_format_t format;
        unsigned int val;
        int dir;
        int rc;
 
        if (s->playback_mode == THREAD && s->thread_started) {
                pthread_mutex_lock(&s->lock);
                s->should_exit_thread = true;
                pthread_mutex_unlock(&s->lock);
                pthread_join(s->thread_id, NULL);
                s->should_exit_thread = false;
                s->thread_started = false;
        }
        if (s->playback_mode == ASYNC && s->pcm_callback) {
                snd_async_del_handler(s->pcm_callback);
                s->pcm_callback = NULL;
        }
 
        s->desc.bps = desc.bps;
        s->desc.ch_count = desc.ch_count;
        s->desc.sample_rate = desc.sample_rate;
 
        if (snd_pcm_state(s->handle) == SND_PCM_STATE_RUNNING) {
                CHECK_OK(snd_pcm_drop(s->handle)); // stop the stream
        }
        snd_pcm_state_t current_state = snd_pcm_state(s->handle);
        if (current_state != SND_PCM_STATE_OPEN &&
                        current_state != SND_PCM_STATE_SETUP) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Unexpected state: %s\n",
                                alsa_get_pcm_state_name(current_state));
        }
 
        /* Allocate a hardware parameters object. */
        snd_pcm_hw_params_alloca(&params);
 
        /* Fill it in with default values. */
        rc = snd_pcm_hw_params_any(s->handle, params);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot obtain default hw parameters: %s\n",
                        snd_strerror(rc));
                return false;
        }
 
        /* Set the desired hardware parameters. */
 
        /* Interleaved mode */
        rc = snd_pcm_hw_params_set_access(s->handle, params,
                        SND_PCM_ACCESS_RW_INTERLEAVED);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot set interleaved hw access: %s\n",
                        snd_strerror(rc));
                rc = snd_pcm_hw_params_set_access(s->handle, params,
                                SND_PCM_ACCESS_RW_NONINTERLEAVED);
                if (rc < 0) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot set non-interleaved hw access: %s\n",
                                        snd_strerror(rc));
                        return false;
                }
                s->non_interleaved = true;
        } else {
                s->non_interleaved = false;
        }
 
        if (desc.bps > 4 || desc.bps < 1) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unsupported BPS for audio (%d).\n",
                                desc.bps * 8);
                return false;
 
        }
        format = bps_to_snd_fmts[desc.bps];
 
        /* Signed 16-bit little-endian format */
        rc = snd_pcm_hw_params_set_format(s->handle, params,
                        format);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot set format: %s\n",
                        snd_strerror(rc));
                return false;
        }
 
        /* Two channels (stereo) */
        rc = snd_pcm_hw_params_set_channels(s->handle, params, desc.ch_count);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot set requested channel count: %s\n",
                                snd_strerror(rc));
                return false;
        }
 
        /* we want to resample if device doesn't support default sample rate */
        val = 1;
        rc = snd_pcm_hw_params_set_rate_resample(s->handle,
                        params, val);
        if(rc < 0) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: Unable to set resampling: %s\n",
                        snd_strerror(rc));
        }
 
 
        /* 44100 bits/second sampling rate (CD quality) */
        val = desc.sample_rate;
        dir = 0;
        rc = snd_pcm_hw_params_set_rate_near(s->handle, params,
                        &val, &dir);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "cannot set requested sample rate: %s\n",
                        snd_strerror(rc));
                return false;
        }
 
        /* Set period to its minimal size.
         *
         * Do not use snd_pcm_hw_params_set_period_time_near(), since it
         * allows to set also unsupported value without notifying. Using
         * snd_pcm_hw_params_set_period_time_first() with Pulseaudio
         * returns invalid argument.
         *
         * See also http://www.alsa-project.org/main/index.php/FramesPeriods */
        s->period_size = 1;
        if (get_commandline_param("alsa-play-period-size")) {
                s->period_size = atoi(get_commandline_param("alsa-play-period-size"));
        }
        dir = 1;
        rc = snd_pcm_hw_params_set_period_size_min(s->handle,
                        params, &s->period_size, &dir);
        if (rc < 0) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: cannot set period time: %s\n",
                        snd_strerror(rc));
        } else {
                log_msg(LOG_LEVEL_INFO, MOD_NAME "Period size: %lu frames (%lf ms)\n", s->period_size, (double) s->period_size / desc.sample_rate * 1000);
        }
 
        set_device_buffer(s->handle, s->playback_mode, params);
 
        /* Write the parameters to the driver */
        rc = snd_pcm_hw_params(s->handle, params);
        if (rc < 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to set hw parameters: %s\n",
                        snd_strerror(rc));
                return false;
        }
 
        snd_pcm_hw_params_current(s->handle, params);
        snd_pcm_hw_params_get_buffer_size(params, &s->buffer_size);
 
        if (s->playback_mode == THREAD || s->playback_mode == ASYNC) {
#ifdef USE_SPEEX_JITTER_BUFFER
                jitter_buffer_reset(s->buf);
#else
                audio_buffer_destroy(s->buf);
                s->audio_buf_len_ms = get_commandline_param("low-latency-audio") ? 5 : s->sched_latency_ms * 2;
                if (get_commandline_param("audio-buffer-len")) {
                        s->audio_buf_len_ms = atoi(get_commandline_param("audio-buffer-len"));
                }
                log_msg(LOG_LEVEL_INFO, "[ALSA play.] Setting audio buffer length: %ld ms\n", s->audio_buf_len_ms);
                s->buf = audio_buffer_init(s->desc.sample_rate, s->desc.bps, s->desc.ch_count, s->audio_buf_len_ms);
#endif
        }
 
        if (s->playback_mode == THREAD) {
                s->timestamp = 0;
                pthread_create(&s->thread_id, NULL, worker, s);
                s->thread_started = true;
        }
 
        if (s->playback_mode == ASYNC) {
                snd_pcm_sw_params_t *sw_params;
                CHECK_OK(snd_pcm_sw_params_malloc(&sw_params));
                CHECK_OK(snd_pcm_sw_params_current (s->handle, sw_params));
                CHECK_OK(snd_pcm_sw_params_set_start_threshold(s->handle, sw_params, s->buffer_size - s->period_size));
                CHECK_OK(snd_pcm_sw_params_set_stop_threshold(s->handle, sw_params, s->buffer_size));
                CHECK_OK(snd_pcm_sw_params_set_avail_min(s->handle, sw_params, s->period_size));
                CHECK_OK(snd_pcm_sw_params(s->handle, sw_params));
                snd_pcm_sw_params_free (sw_params);
 
                EXIT_IF_FAILED(snd_async_add_pcm_handler(&s->pcm_callback, s->handle, alsa_play_async_callback, s), "Add async handler");
 
                write_fill(s);
 
                if (snd_pcm_state(s->handle) == SND_PCM_STATE_PREPARED) {
                        int err = snd_pcm_start(s->handle);
                        if (err < 0) {
                                printf("Start error: %s\n", snd_strerror(err));
                                goto error;
                        }
                }
                if (snd_pcm_state(s->handle) != SND_PCM_STATE_RUNNING) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Device was not running: %s!\n",
                                        alsa_get_pcm_state_name(snd_pcm_state(s->handle)));
                        goto error;
                }
        }
 
        return true;
error:
        return false;
}

References alsa_get_pcm_state_name(), alsa_play_async_callback(), ASYNC, state_alsa_playback::audio_buf_len_ms, audio_buffer_destroy(), audio_buffer_init(), audio_desc::bps, bps_to_snd_fmts, state_alsa_playback::buf, state_alsa_playback::buffer_size, audio_desc::ch_count, CHECK_OK, desc, state_alsa_playback::desc, EXIT_IF_FAILED, get_commandline_param(), state_alsa_playback::handle, state_alsa_playback::lock, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_alsa_playback::non_interleaved, params, state_alsa_playback::pcm_callback, state_alsa_playback::period_size, state_alsa_playback::playback_mode, audio_desc::sample_rate, state_alsa_playback::sched_latency_ms, set_device_buffer(), state_alsa_playback::should_exit_thread, state, THREAD, state_alsa_playback::thread_id, state_alsa_playback::thread_started, state_alsa_playback::timestamp, val, worker(), and write_fill().

Referenced by audio_play_alsa_init().

Here is the call graph for this function:

audio_play_alsa_write_frame()

static void audio_play_alsa_write_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 984 of file alsa.c.

{
        struct state_alsa_playback *s = (struct state_alsa_playback *) state;
        int rc;
 
        if (log_level >= LOG_LEVEL_DEBUG2) {
                snd_pcm_sframes_t delay = 0;
                snd_pcm_delay(s->handle, &delay);
                fprintf(stderr, "Alsa delay: %d samples (%u Hz)\n", (int) delay,
                        (unsigned int) frame->sample_rate);
        }
 
        int frames = frame->data_len / (frame->bps * frame->ch_count);
        rc = write_samples(s->handle, frame->data, frame->bps, frame->ch_count, frames, s->non_interleaved, s->playback_mode, s->scratchpad);
        if (rc == -EPIPE) {
                /* EPIPE means underrun */
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "underrun occurred\n");
                snd_pcm_prepare(s->handle);
                /* fill the stream with some sasmples */
                for (snd_pcm_uframes_t f = 0; f < s->buffer_size; f += frames) {
                        int frames_to_write = frames;
                        if (f + frames > s->buffer_size) {
                                frames_to_write = s->buffer_size - frames;
                        }
                        int rc = write_samples(s->handle, frame->data, frame->bps, frame->ch_count, frames_to_write, s->non_interleaved, s->playback_mode, s->scratchpad);
                        if(rc < 0) {
                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "error from writei: %s\n",
                                                snd_strerror(rc));
                                break;
                        }
                }
        } else if (rc < 0) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "error from writei: %s\n",
                        snd_strerror(rc));
                if (rc == -ENODEV) { // someone pulled the device (eg. videoconferencing
                                     // microphone) out - taking that as a fatal error
                        log_msg(LOG_LEVEL_FATAL, MOD_NAME "Device removed, exiting!\n");
                        exit_uv(EXIT_FAIL_AUDIO);
                }
                snd_pcm_recover(s->handle, rc, 0);
        }  else if (rc != (int)frames) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "short write, written %d frames (overrun)\n", rc);
        }
}

References state_alsa_playback::buffer_size, EXIT_FAIL_AUDIO, exit_uv(), frame, state_alsa_playback::handle, log_level, LOG_LEVEL_DEBUG2, LOG_LEVEL_FATAL, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_alsa_playback::non_interleaved, state_alsa_playback::playback_mode, state_alsa_playback::scratchpad, state, and write_samples().

Referenced by alsa_play_async_callback(), audio_play_alsa_put_frame(), worker(), and write_fill().

Here is the call graph for this function:

get_sched_latency_ns()

static long get_sched_latency_ns ( void )

static

Todo

the file /proc/sys/kernel/sched_latency_ns is no longer present in current Linuxes - remove the function?

Definition at line 156 of file alsa.c.

{
        const char *proc_file = "/proc/sys/kernel/sched_latency_ns";
 
        int fd = open(proc_file, O_RDONLY);
        if (fd == -1) {
                return -1;
        }
 
        char buf[11] = ""; // 9 digits + LF + zero
        unsigned int idx = 0;
        while (idx < sizeof buf - 1) {
                ssize_t bytes = read(fd, buf + idx, sizeof buf - 1 - idx);
                if (bytes < 0) {
                        log_msg(LOG_LEVEL_INFO, "read %s: %s\n", proc_file, strerror(errno));
                        close(fd);
                        return -1;
                }
                if (bytes == 0) {
                        break;
                }
                idx += bytes;
        }
 
        close(fd);
 
        // more than 9 digits (is unlikely)
        if (idx == sizeof buf - 1) {
                return -1;
        }
 
        return atol(buf);
}

References LOG_LEVEL_INFO, and log_msg().

Referenced by audio_play_alsa_init().

Here is the call graph for this function:

init_local_config_with_workaround()

static snd_config_t * init_local_config_with_workaround ( char const * pcm_node_name )

static

Definition at line 770 of file alsa.c.

{
        int r;
        snd_config_t * lconf;
        snd_config_t * device_node;
        snd_config_t * type_node;
        snd_config_t * node;
        char const * type_string;
 
        lconf = NULL;
 
        if (snd_config == NULL) {
                snd_config_update();
        }
 
        r = snd_config_copy(&lconf, snd_config);
        assert(r >= 0);
 
        r = snd_config_search(lconf, pcm_node_name, &device_node);
        if (r != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        /* Fetch the PCM node's type, and bail out if it's not the PulseAudio plugin. */
        r = snd_config_search(device_node, "type", &type_node);
        if (r != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        r = snd_config_get_string(type_node, &type_string);
        if (r != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        if (strcmp(type_string, "pulse") != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        /* Don't clobber an explicit existing handle_underrun value, set it only
           if it doesn't already exist. */
        r = snd_config_search(device_node, "handle_underrun", &node);
        if (r != -ENOENT) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        r = snd_config_imake_integer(&node, "handle_underrun", 0);
        if (r != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        r = snd_config_add(device_node, node);
        if (r != 0) {
                snd_config_delete(lconf);
                return NULL;
        }
 
        return lconf;
}

Referenced by audio_play_alsa_init().

is_default_pulse()

static bool is_default_pulse ( void )

static

Definition at line 722 of file alsa.c.

{
        void **hints;
        bool default_pulse = false;
        bool pulse_present = false;
 
        snd_device_name_hint(-1, "pcm", &hints);
        while(*hints != NULL) {
                char *tmp = strdup(*(char **) hints);
                assert(tmp != NULL);
                char *save_ptr = NULL;
                char *name_part = NULL;
                char *desc = NULL;
 
                assert(strlen(tmp) >= 4);
                name_part = strtok_r(tmp + 4, "|", &save_ptr);
                if (name_part == NULL) {
                        free(tmp);
                        continue;
                }
                desc = strtok_r(NULL, "|", &save_ptr);
 
                if (strcmp(name_part, "default") == 0) {
                        if (desc && strstr(desc, "PulseAudio")) {
                                default_pulse = true;
                        }
                }
 
                if (strcmp(name_part, "pulse") == 0) {
                        pulse_present = true;
                }
 
                hints++;
                free(tmp);
        }
 
        return default_pulse && pulse_present;
}

References desc.

Referenced by audio_play_alsa_init().

REGISTER_MODULE()

REGISTER_MODULE	(	alsa	,
		&	aplay_alsa_info,
		LIBRARY_CLASS_AUDIO_PLAYBACK	,
		AUDIO_PLAYBACK_ABI_VERSION	)

set_device_buffer()

static void set_device_buffer ( snd_pcm_t * handle, playback_mode_t playback_mode, snd_pcm_hw_params_t * params )

static

Definition at line 445 of file alsa.c.

{
        enum {
                REC_MIN_BUF_US = 5000,
        };
        unsigned int buf_len_us = 0;
        int          buf_dir = -1;
        const char  *buff_param = get_commandline_param("alsa-playback-buffer");
 
        if (get_commandline_param("low-latency-audio") != NULL &&
            buff_param == NULL) {
                // set minimal value from the configuration space
                CHECK_OK(snd_pcm_hw_params_set_buffer_time_first(
                    handle, params, &buf_len_us, &buf_dir));
                MSG(INFO, "ALSA driver buffer len set to: %lf ms\n",
                    US_TO_MS((double) buf_len_us));
                if (buf_len_us <= REC_MIN_BUF_US) {
                        MSG(WARNING,
                            "ALSA driver buffer len less than %d usec seem to "
                            "be too loow, consider using alsa-playback-buffer "
                            "instead of low-latency-audio.",
                            REC_MIN_BUF_US);
                }
                return;
        }
 
        buf_len_us = buff_param != NULL ? atoi(buff_param)
                                        : MS_TO_US(playback_mode == SYNC
                                                       ? BUF_LEN_DEFAULT_SYNC_MS
                                                       : BUF_LEN_DEFAULT_MS);
 
        const int rc = snd_pcm_hw_params_set_buffer_time_near(
            handle, params, &buf_len_us, &buf_dir);
        if (rc < 0) {
                MSG(WARNING,
                    "Warning - unable to set buffer to its size %u us: %s\n",
                    buf_len_us, snd_strerror(rc));
        }
        MSG(INFO, "ALSA driver buffer len set to: %lf ms\n",
            US_TO_MS((double) buf_len_us));
}

References BUF_LEN_DEFAULT_MS, BUF_LEN_DEFAULT_SYNC_MS, CHECK_OK, get_commandline_param(), MS_TO_US, MSG, SYNC, and US_TO_MS.

Referenced by audio_play_alsa_reconfigure().

Here is the call graph for this function:

worker()

static void * worker ( void * args )

static

Definition at line 190 of file alsa.c.

                                {
        struct state_alsa_playback *s = args;
 
        struct audio_frame f = { .bps = s->desc.bps,
                .sample_rate = s->desc.sample_rate,
                .ch_count = s->desc.ch_count };
 
        size_t len = f.bps * f.ch_count * (f.sample_rate * s->sched_latency_ms / 1000);
        char *data = alloca(len);
 
#ifdef USE_SPEEX_JITTER_BUFFER
        const int pkt_max_len = s->desc.sample_rate / 10;
        JitterBufferPacket pkt;
        pkt.len = pkt_max_len;
        pkt.data = alloca(pkt_max_len);
#endif
        while (1) {
                pthread_mutex_lock(&s->lock);
                if (s->should_exit_thread) {
                        pthread_mutex_unlock(&s->lock);
                        return NULL;
                }
 
#ifdef USE_SPEEX_JITTER_BUFFER
                int start_offset;
                int err = jitter_buffer_get(s->buf, &pkt, len, &start_offset);
                        jitter_buffer_tick(s->buf);
#else
                int ret = audio_buffer_read(s->buf, data, len);
#endif
                pthread_mutex_unlock(&s->lock);
 
#ifdef USE_SPEEX_JITTER_BUFFER
                if (err == JITTER_BUFFER_OK) {
                        f.data_len = pkt.len;
                        f.data = pkt.data;
                } else {
                        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "empty buffer\n");
                        if (err < 0) {
                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Jitter buffer: %s\n",
                                                JITTER_BUFFER_INTERNAL_ERROR ? "internal error" :
                                                "invalid argument\n");
                        }
                        memset(data, 0, len);
                        f.data_len = len;
                        f.data = data;
                }
                pkt.len = pkt_max_len;
#else
                struct timeval now;
                gettimeofday(&now, NULL);
 
                if (ret > 0) {
                        f.data_len = ret;
                        f.data = data;
                        s->last_audio_read = now;
                } else {
                        memset(data, 0, len);
                        f.data_len = len;
                        f.data = data;
 
                        if (tv_diff(now, s->last_audio_read) < 2.0) {
                                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "empty buffer\n");
                        }
                }
#endif
 
                audio_play_alsa_write_frame(s, &f);
        }
}

References audio_buffer_read(), audio_play_alsa_write_frame(), audio_desc::bps, audio_frame::bps, state_alsa_playback::buf, audio_desc::ch_count, audio_frame::ch_count, audio_frame::data, audio_frame::data_len, state_alsa_playback::desc, state_alsa_playback::last_audio_read, len, state_alsa_playback::lock, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, audio_desc::sample_rate, audio_frame::sample_rate, state_alsa_playback::sched_latency_ms, state_alsa_playback::should_exit_thread, and tv_diff().

Referenced by audio_play_alsa_reconfigure(), display_conference_run(), extract_port(), move_port_to_worker(), recompress_done(), recompress_get_num_active_ports(), recompress_process_async(), stop_grab_workers(), wait_for_frames(), and worker_get_num_active_ports().

Here is the call graph for this function:

write_fill()

static void write_fill ( struct state_alsa_playback * s )

static

Definition at line 428 of file alsa.c.

                                                      {
        struct audio_frame f = { .bps = s->desc.bps,
                .sample_rate = s->desc.sample_rate,
                .ch_count = s->desc.ch_count };
 
        size_t len = f.bps * f.ch_count * s->buffer_size;
        f.data = calloc(1, len);
        f.data_len = len;
 
        audio_play_alsa_write_frame(s, &f);
 
        free(f.data);
}

References audio_play_alsa_write_frame(), audio_desc::bps, audio_frame::bps, state_alsa_playback::buffer_size, audio_desc::ch_count, audio_frame::ch_count, audio_frame::data, audio_frame::data_len, state_alsa_playback::desc, len, and audio_desc::sample_rate.

Referenced by audio_play_alsa_put_frame(), and audio_play_alsa_reconfigure().

Here is the call graph for this function:

write_samples()

static int write_samples ( snd_pcm_t * handle, const char * data, int bps, int ch_count, int frames, bool noninterleaved, playback_mode_t playback_mode, char * tmp_buffer )

static

Definition at line 946 of file alsa.c.

                                                                                                                                                                       {
        char *write_ptr[ch_count]; // for non-interleaved
        long data_len = bps * ch_count * frames;
        if (noninterleaved) {
                assert(frames * bps * ch_count < SCRATCHPAD_SIZE);
                interleaved2noninterleaved(tmp_buffer, data, bps, data_len, ch_count);
                data = tmp_buffer;
        }
        if (bps == 1) { // convert to unsigned
                assert(frames * bps * ch_count < SCRATCHPAD_SIZE);
                signed2unsigned(tmp_buffer, data, data_len); // data may already equal tmp_buffer if noninterleaved, but np, s2u can work in situ
                data = tmp_buffer;
        }
 
        int written = 0;
        while (written < frames) {
                int rc;
                if (noninterleaved) {
                        for (int i = 0; i < ch_count; ++i) {
                                write_ptr[i] = tmp_buffer + frames * bps * i + written * bps;
                        }
                        rc = snd_pcm_writen(handle, (void **) &write_ptr, frames);
                } else {
                        rc = snd_pcm_writei(handle, data, frames - written);
                }
 
                if (rc < 0) {
                        return rc;
                }
                if (playback_mode == SYNC) { // overrun (in non-blocking mode) or signal
                        return rc;
                }
                written += rc;
                data += written * bps * ch_count;
        }
        return written;
}

References audio_desc::bps, audio_desc::ch_count, interleaved2noninterleaved(), SCRATCHPAD_SIZE, signed2unsigned(), and SYNC.

Referenced by audio_play_alsa_write_frame().

Here is the call graph for this function:

Variable Documentation

aplay_alsa_info

const struct audio_playback_info aplay_alsa_info

static

Initial value:

= {
        audio_play_alsa_probe,
        audio_play_alsa_init,
        audio_play_alsa_put_frame,
        audio_play_alsa_ctl,
        audio_play_alsa_reconfigure,
        audio_play_alsa_done
}

Definition at line 1098 of file alsa.c.

                                                          {
        audio_play_alsa_probe,
        audio_play_alsa_init,
        audio_play_alsa_put_frame,
        audio_play_alsa_ctl,
        audio_play_alsa_reconfigure,
        audio_play_alsa_done
};