alsa.c File Reference

#include "config_unix.h"
#include "host.h"
#include "alsa_common.h"
#include "audio/audio_capture.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "lib_common.h"
#include "tv.h"
#include <stdlib.h>
#include <string.h>
#include <alsa/asoundlib.h>

Include dependency graph for alsa.c:

Go to the source code of this file.

Classes
struct	state_alsa_capture

Macros
#define	ALSA_PCM_NEW_HW_PARAMS_API
#define	DEFAULT_SAMPLE_RATE   48000
#define	MOD_NAME   "[ALSA cap.] "

Functions
static void	audio_cap_alsa_done (void *state)
static void	audio_cap_alsa_help (void)
static void *	audio_cap_alsa_init (struct module *parent, const char *cfg)
static void	audio_cap_alsa_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static struct audio_frame *	audio_cap_alsa_read (void *state)
	REGISTER_MODULE (alsa, &acap_alsa_info, LIBRARY_CLASS_AUDIO_CAPTURE, AUDIO_CAPTURE_ABI_VERSION)

Variables
static const struct audio_capture_info	acap_alsa_info
static const int	bps_preference [] = { 2, 4, 3, 1 }

Detailed Description

Author

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

Note

In code below, state_alsa_capture::frame::ch_count can differ from state_alsa_capture::min_device_channels, if device doesn't support mono and we want to capture it. In this case state_alsa_capture::frame::ch_count is set to 1 and min_device_channels to minimal number of channels that device supports.

Definition in file alsa.c.

Macro Definition Documentation

ALSA_PCM_NEW_HW_PARAMS_API

#define ALSA_PCM_NEW_HW_PARAMS_API

Definition at line 48 of file alsa.c.

DEFAULT_SAMPLE_RATE

#define DEFAULT_SAMPLE_RATE   48000

Definition at line 108 of file alsa.c.

Referenced by audio_cap_alsa_init().

MOD_NAME

#define MOD_NAME   "[ALSA cap.] "

Definition at line 67 of file alsa.c.

Referenced by audio_cap_alsa_init(), audio_cap_alsa_read(), audio_play_alsa_init(), audio_play_alsa_put_frame(), audio_play_alsa_query_format(), audio_play_alsa_reconfigure(), audio_play_alsa_write_frame(), and worker().

Function Documentation

audio_cap_alsa_done()

static void audio_cap_alsa_done ( void * state )

static

Definition at line 381 of file alsa.c.

{
        struct state_alsa_capture *s = (struct state_alsa_capture *) state;
        struct timeval t;
 
        gettimeofday(&t, NULL);
        printf("[ALSA cap.] Captured %lld samples in %f seconds (%f samples per second).\n",
                        s->captured_samples, tv_diff(t, s->start_time),
                        s->captured_samples / tv_diff(t, s->start_time));
        snd_pcm_drop(s->handle);
        snd_pcm_close(s->handle);
        free(s->frame.data);
        free(s->tmp_data);
        free(s);
}

References state_alsa_capture::captured_samples, audio_frame::data, state_alsa_capture::frame, state_alsa_capture::handle, state_alsa_capture::start_time, state, state_alsa_capture::tmp_data, and tv_diff().

Here is the call graph for this function:

audio_cap_alsa_help()

static void audio_cap_alsa_help ( void )

static

Definition at line 92 of file alsa.c.

{
        printf("Usage\n");
        color_printf(TERM_BOLD TERM_FG_RED "\t-s alsa\n" TERM_RESET);
        color_printf(TERM_BOLD "\t-s alsa:<device>\n" TERM_RESET);
        color_printf(TERM_BOLD "\t-s alsa:<device>:opts=<opts>\n" TERM_RESET);
        color_printf(TERM_BOLD "\t-s alsa:opts=<opts>\n\n" TERM_RESET);
        color_printf(TERM_BOLD "\t<opts>" TERM_RESET " can be in format key1=value1:key2=value2, options are:\n");
        color_printf(TERM_BOLD "\t\tframes=<frames>" TERM_RESET " number of audio frames captured at a moment\n");
 
        printf("\nAvailable ALSA capture devices\n");
        audio_alsa_list_devices();
}

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

Referenced by audio_cap_alsa_init().

Here is the call graph for this function:

audio_cap_alsa_init()

static void * audio_cap_alsa_init ( struct module * parent, const char * cfg )

static

Definition at line 110 of file alsa.c.

{
        UNUSED(parent);
        if (strcmp(cfg, "help") == 0) {
                audio_cap_alsa_help();
                return INIT_NOERR;
        }
        int rc;
        snd_pcm_hw_params_t *params;
        unsigned int val;
        int dir;
        const char *name = "default";
        char *opts = NULL;
        int format;
        char *tmp = NULL;
 
        struct state_alsa_capture *s = calloc(1, sizeof(struct state_alsa_capture));
 
        if (strlen(cfg) > 0) {
                tmp = strdup(cfg);
                if (strncmp(tmp, "opts=", strlen("opts")) == 0) {
                        opts = tmp + strlen("opts=");
                } else {
                        name = tmp;
                        if (strstr(tmp, ":opts=") != NULL) {
                                opts = strstr(tmp, ":opts=") + strlen(":opts=");
                                *strstr(tmp, ":opts=") = '\0';
                        }
                }
        }
 
        gettimeofday(&s->start_time, NULL);
        s->frame.bps = audio_capture_bps;
        s->frame.sample_rate = audio_capture_sample_rate;
        s->min_device_channels = s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
        s->tmp_data = NULL;
 
        /* Set period size to 128 frames or more. */
        s->frames = 128;
 
        if (opts) {
                char *item, *save_ptr;
                while ((item = strtok_r(opts, ":", &save_ptr)) != NULL) {
                        if (strncmp(item, "frames=", strlen("frames=")) == 0) {
                                s->frames = atoi(item + strlen("frames="));
                        } else {
                                fprintf(stderr, "[ALSA cap.] Unknown option: %s\n", item);
                                goto error;
                        }
                        opts = NULL;
                }
        }
 
        /* Open PCM device for recording (capture). */
        rc = snd_pcm_open(&s->handle, name,
                SND_PCM_STREAM_CAPTURE, 0);
        if (rc < 0) {
                fprintf(stderr, MOD_NAME "unable to open pcm device: %s\n",
                        snd_strerror(rc));
                goto error;
        }
        print_alsa_device_info(s->handle, MOD_NAME);
 
        /* 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) {
                fprintf(stderr, MOD_NAME "unable to set default parameters: %s\n",
                        snd_strerror(rc));
                goto error;
        }
 
        /* Find appropriate parameters if not given by user */
        if (s->frame.bps < 0 || s->frame.bps > 4) {
                log_msg(LOG_LEVEL_ERROR, "[ALSA] %d bits per second are not supported by UG.\n",
                                s->frame.bps * 8);
                goto error;
        }
 
        if (s->frame.bps == 0) {
                for (unsigned int i = 0; i < sizeof bps_preference / sizeof(bps_preference[0]); i++) {
                        if (!snd_pcm_hw_params_test_format(s->handle, params, bps_to_snd_fmts[bps_preference[i]])) {
                                s->frame.bps = bps_preference[i];
                                break;
                        }
                }
                if (s->frame.bps == 0) {
                        bug_msg(LOG_LEVEL_ERROR, MOD_NAME
                                "Cannot find suitable sample format. ");
                        goto error;
                }
        }
 
        if (s->frame.sample_rate == 0) {
                s->frame.sample_rate = get_rate_near(s->handle, params, DEFAULT_SAMPLE_RATE);
                if (s->frame.sample_rate == 0) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot find usable sample rate!\n");
                        goto error;
                }
        }
 
        if (!snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_INTERLEAVED)) {
                s->non_interleaved = false;
        } else if (!snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
                if (s->frame.ch_count > 1) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Non-interleaved mode "
                                        "available only when capturing mono!\n");
                        goto error;
                } else {
                        s->non_interleaved = true;
                }
        } else {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unsupported access mode!\n");
                goto error;
 
        }
 
        /* Set the desired hardware parameters. */
 
        /* Access mode */
        rc = snd_pcm_hw_params_set_access(s->handle, params,
                s->non_interleaved ? SND_PCM_ACCESS_RW_NONINTERLEAVED : SND_PCM_ACCESS_RW_INTERLEAVED);
        if (rc < 0) {
                fprintf(stderr, MOD_NAME "unable to set interleaved mode: %s\n",
                        snd_strerror(rc));
                goto error;
        }
 
        /* Sample format */
        format = bps_to_snd_fmts[s->frame.bps];
        rc = snd_pcm_hw_params_set_format(s->handle, params,
                format);
        if (rc < 0) {
                fprintf(stderr, MOD_NAME "unable to set capture format: %s\n",
                        snd_strerror(rc));
                goto error;
        }
 
        /* 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) {
                fprintf(stderr, MOD_NAME "Warning: Unable to set resampling: %s\n",
                        snd_strerror(rc));
        }
 
        /* set sampling rate */
        val = s->frame.sample_rate;
        dir = 0;
        rc = snd_pcm_hw_params_set_rate_near(s->handle, params,
                &val, &dir);
        if (rc < 0) {
                fprintf(stderr, "[ALSA cap.] unable to set sampling rate (%s %d): %s\n",
                        dir == 0 ? "=" : (dir == -1 ? "<" : ">"),
                        val, snd_strerror(rc));
                goto error;
        }
 
        /* Channels count */
        rc = snd_pcm_hw_params_set_channels(s->handle, params, s->frame.ch_count);
        if (rc < 0) {
                if (s->frame.ch_count == 1) { // some devices cannot do mono
                        snd_pcm_hw_params_set_channels_first(s->handle, params, &s->min_device_channels);
                } else {
                        fprintf(stderr, MOD_NAME "unable to set channel count: %s\n",
                                        snd_strerror(rc));
                        goto error;
                }
        }
 
        /* This must be set after setting of sample rate for Chat 150 which increases
         * value to 1024. But if this setting precedes, setting sample rate of 48000
         * fails (1024 period) or does not work properly (128).
         * */
        dir = 0;
        rc = snd_pcm_hw_params_set_period_size_near(s->handle,
                params, &s->frames, &dir);
        if (rc < 0) {
                fprintf(stderr, "[ALSA cap.] unable to set frame period (%ld): %s\n",
                                s->frames, snd_strerror(rc));
        }
 
        /* Write the parameters to the driver */
        rc = snd_pcm_hw_params(s->handle, params);
        if (rc < 0) {
                fprintf(stderr, MOD_NAME "unable to set hw parameters: %s\n",
                        snd_strerror(rc));
                goto error;
        }
 
        /* Use a buffer large enough to hold one period */
        snd_pcm_hw_params_get_period_size(params, &s->frames, &dir);
        s->frame.max_size = s->frames  * s->frame.ch_count * s->frame.bps;
        s->frame.data = (char *) malloc(s->frame.max_size);
 
        s->tmp_data = malloc(s->frames  * s->min_device_channels * s->frame.bps);
 
        log_msg(LOG_LEVEL_NOTICE, "ALSA capture configuration: %d channel%s, %d Bps, %d Hz, "
                       "%ld samples per frame.\n", s->frame.ch_count,
                       s->frame.ch_count == 1 ? "" : "s", s->frame.bps,
                       s->frame.sample_rate, s->frames);
 
        free(tmp);
        return s;
 
error:
        free(s);
        free(tmp);
        return NULL;
}

References audio_cap_alsa_help(), audio_capture_bps, audio_capture_channels, audio_capture_sample_rate, audio_frame::bps, bps_preference, bps_to_snd_fmts, bug_msg(), audio_frame::ch_count, audio_frame::data, DEFAULT_AUDIO_CAPTURE_CHANNELS, DEFAULT_SAMPLE_RATE, state_alsa_capture::frame, state_alsa_capture::frames, get_rate_near(), state_alsa_capture::handle, INIT_NOERR, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, log_msg(), audio_frame::max_size, state_alsa_capture::min_device_channels, MOD_NAME, name, state_alsa_capture::non_interleaved, params, parent, print_alsa_device_info(), audio_frame::sample_rate, state_alsa_capture::start_time, state_alsa_capture::tmp_data, UNUSED, and val.

Here is the call graph for this function:

audio_cap_alsa_probe()

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

static

Definition at line 83 of file alsa.c.

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

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

Here is the call graph for this function:

audio_cap_alsa_read()

static struct audio_frame * audio_cap_alsa_read ( void * state )

static

Definition at line 324 of file alsa.c.

{
        struct state_alsa_capture *s = (struct state_alsa_capture *) state;
        int rc;
        char *discard_data;
 
        char *read_ptr[s->min_device_channels];
        read_ptr[0] = s->frame.data;
        if((int) s->min_device_channels > s->frame.ch_count && s->frame.ch_count == 1) {
                read_ptr[0] = s->tmp_data;
        }
 
        if (s->non_interleaved) {
                assert(s->frame.ch_count == 1);
                discard_data = (char *) alloca(s->frames * s->frame.bps * (s->min_device_channels-1));
                for (unsigned int i = 1; i < s->min_device_channels; ++i) {
                        read_ptr[i] = discard_data + (i - 1) * s->frames * s->frame.bps;
                }
                rc = snd_pcm_readn(s->handle, (void **) read_ptr, s->frames);
        } else {
                rc = snd_pcm_readi(s->handle, read_ptr[0], s->frames);
        }
        if (rc == -EPIPE) {
                /* EPIPE means overrun */
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "overrun occurred\n");
                snd_pcm_prepare(s->handle);
        } else if (rc < 0) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "error from read: %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);
                }
        } else if (rc != (int)s->frames) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "short read, read %d frames\n", rc);
        }
 
        if(rc > 0) {
                if ((int) s->min_device_channels > s->frame.ch_count && s->frame.ch_count == 1) {
                        demux_channel(s->frame.data, (char *) s->tmp_data, s->frame.bps,
                                        rc * s->frame.bps * s->min_device_channels,
                                        s->min_device_channels, /* channels (originally) */
                                        0 /* we want first channel */
                                );
                }
                s->frame.data_len = rc * s->frame.bps * s->frame.ch_count;
                if (s->frame.bps == 1) {
                        // should be unsigned2signed but it works in both directions
                        signed2unsigned(s->frame.data, s->frame.data, s->frame.data_len);
                }
                s->captured_samples += rc;
                return &s->frame;
        } else {
                return NULL;
        }
}

References audio_frame::bps, state_alsa_capture::captured_samples, audio_frame::ch_count, audio_frame::data, audio_frame::data_len, demux_channel(), EXIT_FAIL_AUDIO, exit_uv(), state_alsa_capture::frame, state_alsa_capture::frames, state_alsa_capture::handle, LOG_LEVEL_FATAL, LOG_LEVEL_WARNING, log_msg(), state_alsa_capture::min_device_channels, MOD_NAME, state_alsa_capture::non_interleaved, signed2unsigned(), state, and state_alsa_capture::tmp_data.

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	alsa	,
		&	acap_alsa_info,
		LIBRARY_CLASS_AUDIO_CAPTURE	,
		AUDIO_CAPTURE_ABI_VERSION	)

Variable Documentation

acap_alsa_info

const struct audio_capture_info acap_alsa_info

static

Initial value:

= {
        audio_cap_alsa_probe,
        audio_cap_alsa_init,
        audio_cap_alsa_read,
        audio_cap_alsa_done
}

Definition at line 397 of file alsa.c.

                                                        {
        audio_cap_alsa_probe,
        audio_cap_alsa_init,
        audio_cap_alsa_read,
        audio_cap_alsa_done
};

bps_preference

const int bps_preference[] = { 2, 4, 3, 1 }

static

Definition at line 106 of file alsa.c.

{ 2, 4, 3, 1 };

Referenced by audio_cap_alsa_init().