N-sim Emulation and simulation of Wireless Sensor Networks    Home    Project Page    Download    CVS    Installation    Configuration    Plug-ins  Hosted by

/home/brennan/n-sim/Vaike/linux/system-addons/drivers/raw_audio.c Go to the documentation of this file. /* * Copyright 2007. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program is free software; you can redistribute * it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; version 2 of * the License. Accordingly, this program is distributed in the hope * it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. */ #define _GNU_SOURCE #include <stdio.h> #include <malloc.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <getopt.h> #include <fcntl.h> #include <ctype.h> #include <errno.h> #include <limits.h> #include <locale.h> #include <alsa/asoundlib.h> #include <assert.h> #include <sys/types.h> #include <sys/poll.h> #include <sys/uio.h> #include <sys/time.h> #include <sys/signal.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <asm/byteorder.h> #if 0 #include "aconfig.h" #include "gettext.h" #include "formats.h" #include "version.h" #endif // FIXME: convert to miniSoap #ifndef LLONG_MAX #define LLONG_MAX 9223372036854775807LL #endif #define DEFAULT_FORMAT SND_PCM_FORMAT_U8 #define DEFAULT_SPEED 4000 #define FORMAT_DEFAULT -1 #define FORMAT_RAW 0 #define FORMAT_VOC 1 #define FORMAT_WAVE 2 #define FORMAT_AU 3 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) #define error(...) do {\ fprintf(stderr, "%s: %s:%d: ", command, __FUNCTION__, __LINE__); \ fprintf(stderr, __VA_ARGS__); \ putc('\n', stderr); \ } while (0) #else #define error(args...) do {\ fprintf(stderr, "%s: %s:%d: ", command, __FUNCTION__, __LINE__); \ fprintf(stderr, ##args); \ putc('\n', stderr); \ } while (0) #endif static snd_pcm_sframes_t (*readi_func)(snd_pcm_t *handle, void *buffer, snd_pcm_uframes_t size); static char *command; static snd_pcm_t *handle; static struct { snd_pcm_format_t format; unsigned int channels; unsigned int rate; } hwparams, rhwparams; static int timelimit = 10; // 0 continues forever, but eventually fails static int quiet_mode = 0; static int file_type = FORMAT_RAW; static unsigned int sleep_min = 0; static int open_mode = 0; static snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE; static int mmap_flag = 0; static int interleaved = 1; static int nonblock = 0; static snd_pcm_uframes_t chunk_size = 0; static unsigned period_time = 0; static unsigned buffer_time = 0; static snd_pcm_uframes_t period_frames = 0; static snd_pcm_uframes_t buffer_frames = 0; static int avail_min = -1; static int start_delay = 0; static int stop_delay = 0; static int verbose = 0; static size_t bits_per_sample, bits_per_frame; static size_t chunk_bytes; static snd_output_t *log; struct timeval ttime; snd_pcm_info_t *info; static off64_t pbrec_count = LLONG_MAX; char *pcm_name = "default"; static size_t set_params(void) { snd_pcm_hw_params_t *params; snd_pcm_sw_params_t *swparams; snd_pcm_uframes_t buffer_size; int err; size_t n; snd_pcm_uframes_t xfer_align; unsigned int rate; snd_pcm_uframes_t start_threshold, stop_threshold; snd_pcm_hw_params_alloca(&params); snd_pcm_sw_params_alloca(&swparams); err = snd_pcm_hw_params_any(handle, params); if (err < 0) { error("Broken configuration for this PCM: no configurations available"); exit(EXIT_FAILURE); } if (mmap_flag) { snd_pcm_access_mask_t *mask = alloca(snd_pcm_access_mask_sizeof()); snd_pcm_access_mask_none(mask); snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_COMPLEX); err = snd_pcm_hw_params_set_access_mask(handle, params, mask); } else if (interleaved) err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED); else err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_NONINTERLEAVED); if (err < 0) { error("Access type not available"); exit(EXIT_FAILURE); } err = snd_pcm_hw_params_set_format(handle, params, hwparams.format); if (err < 0) { error("Sample format non available"); exit(EXIT_FAILURE); } err = snd_pcm_hw_params_set_channels(handle, params, hwparams.channels); if (err < 0) { error("Channels count non available"); exit(EXIT_FAILURE); } #if 0 err = snd_pcm_hw_params_set_periods_min(handle, params, 2); assert(err >= 0); #endif rate = hwparams.rate; err = snd_pcm_hw_params_set_rate_near(handle, params, &hwparams.rate, 0); assert(err >= 0); if ((float)rate * 1.05 < hwparams.rate || (float)rate * 0.95 > hwparams.rate) { if (!quiet_mode) { char plugex[64]; const char *pcmname = snd_pcm_name(handle); fprintf(stderr, "Warning: rate is not accurate (requested = %iHz, got = %iHz)\n", rate, hwparams.rate); if (! pcmname || strchr(snd_pcm_name(handle), ':')) *plugex = 0; else snprintf(plugex, sizeof(plugex), "(-Dplug:%s)", snd_pcm_name(handle)); fprintf(stderr, " please, try the plug plugin %s\n", plugex); } } rate = hwparams.rate; if (buffer_time == 0 && buffer_frames == 0) { err = snd_pcm_hw_params_get_buffer_time_max(params, &buffer_time, 0); assert(err >= 0); if (buffer_time > 500000) buffer_time = 500000; } if (period_time == 0 && period_frames == 0) { if (buffer_time > 0) period_time = buffer_time / 4; else period_frames = buffer_frames / 4; //period_frames = buffer_frames / 2; } if (period_time > 0) err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, 0); else err = snd_pcm_hw_params_set_period_size_near(handle, params, &period_frames, 0); assert(err >= 0); if (buffer_time > 0) { err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, 0); } else { err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_frames); } assert(err >= 0); err = snd_pcm_hw_params(handle, params); if (err < 0) { error("Unable to install hw params:"); snd_pcm_hw_params_dump(params, log); exit(EXIT_FAILURE); } snd_pcm_hw_params_get_period_size(params, &chunk_size, 0); snd_pcm_hw_params_get_buffer_size(params, &buffer_size); if (chunk_size == buffer_size) { error("Can't use period equal to buffer size (%lu == %lu)", chunk_size, buffer_size); exit(EXIT_FAILURE); } snd_pcm_sw_params_current(handle, swparams); err = snd_pcm_sw_params_get_xfer_align(swparams, &xfer_align); if (err < 0) { error("Unable to obtain xfer align\n"); exit(EXIT_FAILURE); } if (sleep_min) xfer_align = 1; err = snd_pcm_sw_params_set_sleep_min(handle, swparams, sleep_min); assert(err >= 0); if (avail_min < 0) n = chunk_size; else n = (double) rate * avail_min / 1000000; err = snd_pcm_sw_params_set_avail_min(handle, swparams, n); /* round up to closest transfer boundary */ n = (buffer_size / xfer_align) * xfer_align; if (start_delay <= 0) { start_threshold = n + (double) rate * start_delay / 1000000; } else start_threshold = (double) rate * start_delay / 1000000; if (start_threshold < 1) start_threshold = 1; if (start_threshold > n) start_threshold = n; err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold); assert(err >= 0); if (stop_delay <= 0) stop_threshold = buffer_size + (double) rate * stop_delay / 1000000; else stop_threshold = (double) rate * stop_delay / 1000000; err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold); assert(err >= 0); err = snd_pcm_sw_params_set_xfer_align(handle, swparams, xfer_align); assert(err >= 0); if (snd_pcm_sw_params(handle, swparams) < 0) { error("unable to install sw params:"); snd_pcm_sw_params_dump(swparams, log); exit(EXIT_FAILURE); } if (verbose) snd_pcm_dump(handle, log); bits_per_sample = snd_pcm_format_physical_width(hwparams.format); bits_per_frame = bits_per_sample * hwparams.channels; chunk_bytes = chunk_size * bits_per_frame / 8; return chunk_bytes; } int audio_open(void) { int error; snd_pcm_info_alloca(&info); error = snd_output_stdio_attach(&log, stderr, 0); assert(error >= 0); file_type = FORMAT_RAW; start_delay=1; chunk_size = -1; rhwparams.format = SND_PCM_FORMAT_U16_LE; rhwparams.rate = DEFAULT_SPEED; rhwparams.channels = 1; if ((error = snd_pcm_open(&handle, pcm_name, stream, open_mode)) < 0) error("audio open error: %s", snd_strerror(error)); if ((error = snd_pcm_info(handle, info)) < 0) error("info error: %s", snd_strerror(error)); if (nonblock) { if ((error = snd_pcm_nonblock(handle, 1)) < 0) error("nonblock setting error: %s", snd_strerror(error)); } chunk_size = 1024; hwparams = rhwparams; if (mmap_flag) { readi_func = snd_pcm_mmap_readi; } else { readi_func = snd_pcm_readi; } return set_params(); } void audio_close(void) { snd_pcm_close(handle); snd_output_close(log); snd_config_update_free_global(); } /**************************************************/ /* * Safe read (for pipes) */ #if 0 ssize_t safe_read(int fd, void *buf, size_t count) { ssize_t result = 0, res; while (count > 0) { if ((res = read(fd, buf, count)) == 0) break; if (res < 0) return result > 0 ? result : res; count -= res; result += res; buf = (char *)buf + res; } return result; } #endif #ifndef timersub #define timersub(a, b, result) \ do { \ (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ if ((result)->tv_usec < 0) { \ --(result)->tv_sec; \ (result)->tv_usec += 1000000; \ } \ } while (0) #endif /* I/O error handler */ static void xrun(void) { snd_pcm_status_t *status; int res; snd_pcm_status_alloca(&status); if ((res = snd_pcm_status(handle, status))<0) { error("status error: %s", snd_strerror(res)); exit(EXIT_FAILURE); } if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) { struct timeval now, diff, tstamp; gettimeofday(&now, 0); snd_pcm_status_get_trigger_tstamp(status, &tstamp); timersub(&now, &tstamp, &diff); fprintf(stderr, "%s!!! (at least %.3f ms long)\n", stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun", diff.tv_sec * 1000 + diff.tv_usec / 1000.0); if (verbose) { fprintf(stderr, "Status:\n"); snd_pcm_status_dump(status, log); } if ((res = snd_pcm_prepare(handle))<0) { error("xrun: prepare error: %s", snd_strerror(res)); exit(EXIT_FAILURE); } return; /* ok, data should be accepted again */ } if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) { if (verbose) { fprintf(stderr, "Status(DRAINING):\n"); snd_pcm_status_dump(status, log); } if (stream == SND_PCM_STREAM_CAPTURE) { fprintf(stderr, "capture stream format change? attempting recover...\n"); if ((res = snd_pcm_prepare(handle))<0) { error("xrun(DRAINING): prepare error: %s", snd_strerror(res)); exit(EXIT_FAILURE); } return; } } if (verbose) { fprintf(stderr, "Status(R/W):\n"); snd_pcm_status_dump(status, log); } error("read/write error, state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status))); exit(EXIT_FAILURE); } /* I/O suspend handler */ static void suspend(void) { int res; if (!quiet_mode) fprintf(stderr, "Suspended. Trying resume. "); fflush(stderr); while ((res = snd_pcm_resume(handle)) == -EAGAIN) sleep(1); /* wait until suspend flag is released */ if (res < 0) { if (!quiet_mode) fprintf(stderr, "Failed. Restarting stream. "); fflush(stderr); if ((res = snd_pcm_prepare(handle)) < 0) { error("suspend: prepare error: %s", snd_strerror(res)); exit(EXIT_FAILURE); } } if (!quiet_mode) fprintf(stderr, "Done.\n"); } /**************************************************/ /**************************************************/ /* peak handler */ static void compute_max_peak(u_char *data, size_t count) { signed int val, max, max_peak = 0, perc; static int run = 0; int format_little_endian = snd_pcm_format_little_endian(hwparams.format); switch (bits_per_sample) { case 8: { signed char *valp = (signed char *)data; signed char mask = snd_pcm_format_silence(hwparams.format); while (count-- > 0) { val = *valp++ ^ mask; val = abs(val); if (max_peak < val) max_peak = val; } break; } case 16: { signed short *valp = (signed short *)data; signed short mask = snd_pcm_format_silence_16(hwparams.format); signed short sval; count /= 2; while (count-- > 0) { if (format_little_endian) sval = __le16_to_cpu(*valp); else sval = __be16_to_cpu(*valp); sval = abs(sval) ^ mask; if (max_peak < sval) max_peak = sval; valp++; } break; } case 24: { unsigned char *valp = data; signed int mask = snd_pcm_format_silence_32(hwparams.format); count /= 3; while (count-- > 0) { if (format_little_endian) { val = valp[0] | (valp[1]<<8) | (valp[2]<<16); } else { val = (valp[0]<<16) | (valp[1]<<8) | valp[2]; } /* Correct signed bit in 32-bit value */ if (val & (1<<(bits_per_sample-1))) { val |= 0xff<<24; /* Negate upper bits too */ } val = abs(val) ^ mask; if (max_peak < val) max_peak = val; valp += 3; } break; } case 32: { signed int *valp = (signed int *)data; signed int mask = snd_pcm_format_silence_32(hwparams.format); count /= 4; while (count-- > 0) { if (format_little_endian) val = __le32_to_cpu(*valp); else val = __be32_to_cpu(*valp); val = abs(val) ^ mask; if (max_peak < val) max_peak = val; valp++; } break; } default: if (run == 0) { run = 1; } return; } max = 1 << (bits_per_sample-1); if (max <= 0) max = 0x7fffffff; if (bits_per_sample > 16) perc = max_peak / (max / 100); else perc = max_peak * 100 / max; } int consume_audio(u_char *data, size_t rcount) { ssize_t r; size_t result = 0; size_t count = rcount; if (sleep_min == 0 && count != chunk_size) { count = chunk_size; } while (count > 0) { r = readi_func(handle, data, count); if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) { snd_pcm_wait(handle, 1000); } else if (r == -EPIPE) { xrun(); } else if (r == -ESTRPIPE) { suspend(); } else if (r < 0) { error("read error: %s", snd_strerror(r)); exit(EXIT_FAILURE); } if (r > 0) { if (verbose > 1) compute_max_peak(data, r * hwparams.channels); result += r; count -= r; data += r * bits_per_frame / 8; } } return rcount; } /* calculate the data count to read from/to dsp */ static off64_t calc_count(void) { off64_t count; if (timelimit == 0) { count = pbrec_count; } else { count = snd_pcm_format_size(hwparams.format, hwparams.rate * hwparams.channels); count *= (off64_t)timelimit; } return count < pbrec_count ? count : pbrec_count; }

© 2007, Los Alamos National Security, LLC.