/*
** Copyright 2010, The Android Open-Source Project
** Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <sys/poll.h>
#include <sys/ioctl.h>
#include <getopt.h>
#include <limits.h>
#include "alsa_audio.h"
#define ID_RIFF 0x46464952
#define ID_WAVE 0x45564157
#define ID_FMT 0x20746d66
#define ID_DATA 0x61746164
#define FORMAT_PCM 1
#ifndef ANDROID
#define strlcat g_strlcat
#define strlcpy g_strlcpy
#endif
static struct wav_header hdr;
static int fd;
static struct pcm *pcm;
static int debug = 0;
static int pcm_flag = 1;
static int duration = 0;
static char *filename;
static char *data;
static int format = SNDRV_PCM_FORMAT_S16_LE;
static int period = 0;
static int piped = 0;
static struct option long_options[] =
{
{"pcm", 0, 0, 'P'},
{"debug", 0, 0, 'V'},
{"Mmap", 0, 0, 'M'},
{"HW", 1, 0, 'D'},
{"Rate", 1, 0, 'R'},
{"channel", 1, 0, 'C'},
{"duration", 1, 0, 'T'},
{"format", 1, 0, 'F'},
{"period", 1, 0, 'B'},
{0, 0, 0, 0}
};
struct wav_header {
uint32_t riff_id;
uint32_t riff_sz;
uint32_t riff_fmt;
uint32_t fmt_id;
uint32_t fmt_sz;
uint16_t audio_format;
uint16_t num_channels;
uint32_t sample_rate;
uint32_t byte_rate; /* sample_rate * num_channels * bps / 8 */
uint16_t block_align; /* num_channels * bps / 8 */
uint16_t bits_per_sample;
uint32_t data_id;
uint32_t data_sz;
};
static int set_params(struct pcm *pcm)
{
struct snd_pcm_hw_params *params;
struct snd_pcm_sw_params *sparams;
unsigned long periodSize, bufferSize, reqBuffSize;
unsigned int periodTime, bufferTime;
unsigned int requestedRate = pcm->rate;
params = (struct snd_pcm_hw_params*) calloc(1, sizeof(struct snd_pcm_hw_params));
if (!params) {
fprintf(stderr, "Arec:Failed to allocate ALSA hardware parameters!");
return -ENOMEM;
}
param_init(params);
param_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS,
(pcm->flags & PCM_MMAP)? SNDRV_PCM_ACCESS_MMAP_INTERLEAVED : SNDRV_PCM_ACCESS_RW_INTERLEAVED);
param_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT, pcm->format);
param_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT,
SNDRV_PCM_SUBFORMAT_STD);
if (period)
param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, period);
else
param_set_min(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 10);
param_set_int(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 16);
param_set_int(params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
pcm->channels * 16);
param_set_int(params, SNDRV_PCM_HW_PARAM_CHANNELS,
pcm->channels);
param_set_int(params, SNDRV_PCM_HW_PARAM_RATE, pcm->rate);
param_set_hw_refine(pcm, params);
if (param_set_hw_params(pcm, params)) {
fprintf(stderr, "Arec:cannot set hw params");
return -errno;
}
if (debug)
param_dump(params);
pcm->buffer_size = pcm_buffer_size(params);
pcm->period_size = pcm_period_size(params);
pcm->period_cnt = pcm->buffer_size/pcm->period_size;
if (debug) {
fprintf (stderr,"period_size (%d)", pcm->period_size);
fprintf (stderr," buffer_size (%d)", pcm->buffer_size);
fprintf (stderr," period_cnt (%d)\n", pcm->period_cnt);
}
sparams = (struct snd_pcm_sw_params*) calloc(1, sizeof(struct snd_pcm_sw_params));
if (!sparams) {
fprintf(stderr, "Arec:Failed to allocate ALSA software parameters!\n");
return -ENOMEM;
}
sparams->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
sparams->period_step = 1;
if (pcm->flags & PCM_MONO) {
sparams->avail_min = pcm->period_size/2;
sparams->xfer_align = pcm->period_size/2;
} else if (pcm->flags & PCM_QUAD) {
sparams->avail_min = pcm->period_size/8;
sparams->xfer_align = pcm->period_size/8;
} else if (pcm->flags & PCM_5POINT1) {
sparams->avail_min = pcm->period_size/12;
sparams->xfer_align = pcm->period_size/12;
} else {
sparams->avail_min = pcm->period_size/4;
sparams->xfer_align = pcm->period_size/4;
}
sparams->start_threshold = 1;
sparams->stop_threshold = INT_MAX;
sparams->silence_size = 0;
sparams->silence_threshold = 0;
if (param_set_sw_params(pcm, sparams)) {
fprintf(stderr, "Arec:cannot set sw params");
return -errno;
}
if (debug) {
fprintf (stderr,"avail_min (%lu)\n", sparams->avail_min);
fprintf (stderr,"start_threshold (%lu)\n", sparams->start_threshold);
fprintf (stderr,"stop_threshold (%lu)\n", sparams->stop_threshold);
fprintf (stderr,"xfer_align (%lu)\n", sparams->xfer_align);
}
return 0;
}
int record_file(unsigned rate, unsigned channels, int fd, unsigned count, unsigned flags, const char *device)
{
unsigned xfer, bufsize;
int r, avail;
int nfds = 1;
static int start = 0;
struct snd_xferi x;
long frames;
unsigned offset = 0;
int err;
struct pollfd pfd[1];
int rec_size = 0;
flags |= PCM_IN;
if (channels == 1)
flags |= PCM_MONO;
else if (channels == 4)
flags |= PCM_QUAD;
else if (channels == 6)
flags |= PCM_5POINT1;
else
flags |= PCM_STEREO;
pcm = pcm_open(flags, device);
if (!pcm_ready(pcm)) {
pcm_close(pcm);
goto fail;
}
pcm->channels = channels;
pcm->rate = rate;
pcm->flags = flags;
pcm->format = format;
if (set_params(pcm)) {
fprintf(stderr, "Arec:params setting failed\n");
pcm_close(pcm);
return -EINVAL;
}
if (!pcm_flag) {
if (pcm_prepare(pcm)) {
fprintf(stderr, "Arec:Failed in pcm_prepare\n");
pcm_close(pcm);
return -errno;
}
if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
fprintf(stderr, "Arec: Hostless IOCTL_START Error no %d \n", errno);
pcm_close(pcm);
return -errno;
}
while(1);
}
if (flags & PCM_MMAP) {
u_int8_t *dst_addr = NULL;
struct snd_pcm_sync_ptr *sync_ptr1 = pcm->sync_ptr;
unsigned int tmp;
if (mmap_buffer(pcm)) {
fprintf(stderr, "Arec:params setting failed\n");
pcm_close(pcm);
return -EINVAL;
}
if (debug)
fprintf(stderr, "Arec:mmap_buffer done\n");
if (pcm_prepare(pcm)) {
fprintf(stderr, "Arec:Failed in pcm_prepare\n");
pcm_close(pcm);
return -errno;
}
bufsize = pcm->period_size;
if (debug)
fprintf(stderr, "Arec:bufsize = %d\n", bufsize);
if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START)) {
if (errno == EPIPE) {
fprintf(stderr, "Arec:Failed in SNDRV_PCM_IOCTL_START\n");
/* we failed to make our window -- try to restart */
pcm->running = 0;
} else {
fprintf(stderr, "Arec:Error no %d \n", errno);
return -errno;
}
}
pfd[0].fd = pcm->fd;
pfd[0].events = POLLIN;
hdr.data_sz = 0;
if (pcm->flags & PCM_MONO) {
frames = bufsize / 2;
} else if (pcm->flags & PCM_QUAD) {
frames = bufsize / 8;
} else if (pcm->flags & PCM_5POINT1) {
frames = bufsize / 12;
} else{
frames = bufsize / 4;
}
x.frames = frames;
for(;;) {
if (!pcm->running) {
if (pcm_prepare(pcm))
return --errno;
start = 0;
}
/* Sync the current Application pointer from the kernel */
pcm->sync_ptr->flags = SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN;//SNDRV_PCM_SYNC_PTR_HWSYNC;
err = sync_ptr(pcm);
if (err == EPIPE) {
fprintf(stderr, "Arec:Failed in sync_ptr \n");
/* we failed to make our window -- try to restart */
//pcm->overruns++;
pcm->running = 0;
continue;
}
/*
* Check for the available data in driver. If available data is
* less than avail_min we need to wait
*/
avail = pcm_avail(pcm);
if (debug)
fprintf(stderr, "Arec:avail 1 = %d frames = %ld\n",avail, frames);
if (avail < 0)
return avail;
if (avail < pcm->sw_p->avail_min) {
poll(pfd, nfds, TIMEOUT_INFINITE);
continue;
}
if (x.frames > avail)
frames = avail;
/*
* Now that we have data size greater than avail_min available to
* to be read we need to calcutate the buffer offset where we can
* start reading from.
*/
dst_addr = dst_address(pcm);
/*
* Write to the file at the destination address from kernel mmaped buffer
* This reduces a extra copy of intermediate buffer.
*/
if (write(fd, dst_addr, bufsize) != bufsize) {
fprintf(stderr, "Arec:could not write %d bytes\n", bufsize);
return -errno;
}
x.frames -= frames;
pcm->sync_ptr->c.control.appl_ptr += frames;
pcm->sync_ptr->flags = 0;
err = sync_ptr(pcm);
if (err == EPIPE) {
fprintf(stderr, "Arec:Failed in sync_ptr \n");
/* we failed to make our window -- try to restart */
pcm->running = 0;
continue;
}
rec_size += bufsize;
hdr.data_sz += bufsize;
hdr.riff_sz = hdr.data_sz + 44 - 8;
if (!piped) {
lseek(fd, 0, SEEK_SET);
write(fd, &hdr, sizeof(hdr));
lseek(fd, 0, SEEK_END);
}
if (rec_size >= count)
break;
}
} else {
bufsize = pcm->period_size;
if (pcm_prepare(pcm)) {
fprintf(stderr, "Arec:Failed in pcm_prepare\n");
pcm_close(pcm);
return -errno;
}
data = calloc(1, bufsize);
if (!data) {
fprintf(stderr, "Arec:could not allocate %d bytes\n", bufsize);
return -ENOMEM;
}
while (!pcm_read(pcm, data, bufsize)) {
if (write(fd, data, bufsize) != bufsize) {
fprintf(stderr, "Arec:could not write %d bytes\n", bufsize);
break;
}
rec_size += bufsize;
hdr.data_sz += bufsize;
hdr.riff_sz = hdr.data_sz + 44 - 8;
if (!piped) {
lseek(fd, 0, SEEK_SET);
write(fd, &hdr, sizeof(hdr));
lseek(fd, 0, SEEK_END);
}
if (rec_size >= count)
break;
}
}
fprintf(stderr, " rec_size =%d count =%d\n", rec_size, count);
close(fd);
free(data);
pcm_close(pcm);
return hdr.data_sz;
fail:
fprintf(stderr, "Arec:pcm error: %s\n", pcm_error(pcm));
return -errno;
}
int rec_raw(const char *fg, const char *device, int rate, int ch,
const char *fn)
{
unsigned flag = 0;
uint32_t rec_max_sz = 2147483648LL;
uint32_t count;
int i = 0;
if (!fn) {
fd = fileno(stdout);
piped = 1;
} else {
fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0664);
if (fd < 0) {
fprintf(stderr, "Arec:arec: cannot open '%s'\n", fn);
return -EBADFD;
}
}
if (duration == 0) {
count = rec_max_sz;
} else {
count = rate * ch * 2;
count *= (uint32_t)duration;
}
count = count < rec_max_sz ? count : rec_max_sz;
if (debug)
fprintf(stderr, "arec: %d ch, %d hz, %d bit, format %x\n",
ch, rate, 16, format);
if (!strncmp(fg, "M", sizeof("M"))) {
flag = PCM_MMAP;
} else if (!strncmp(fg, "N", sizeof("N"))) {
flag = PCM_NMMAP;
}
return record_file(rate, ch, fd, count, flag, device);
}
int rec_wav(const char *fg, const char *device, int rate, int ch, const char *fn)
{
unsigned flag = 0;
uint32_t rec_max_sz = 2147483648LL;
uint32_t count = 0;
int i = 0;
if (pcm_flag) {
if (!fn) {
fd = fileno(stdout);
piped = 1;
} else {
fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0664);
if (fd < 0) {
fprintf(stderr, "Arec:arec: cannot open '%s'\n", fn);
return -EBADFD;
}
}
memset(&hdr, 0, sizeof(struct wav_header));
hdr.riff_id = ID_RIFF;
hdr.riff_fmt = ID_WAVE;
hdr.fmt_id = ID_FMT;
hdr.fmt_sz = 16;
hdr.audio_format = FORMAT_PCM;
hdr.num_channels = ch;
hdr.sample_rate = rate;
hdr.bits_per_sample = 16;
hdr.byte_rate = (rate * ch * hdr.bits_per_sample) / 8;
hdr.block_align = ( hdr.bits_per_sample * ch ) / 8;
hdr.data_id = ID_DATA;
hdr.data_sz = 0;
if (duration == 0) {
count = rec_max_sz;
} else {
count = rate * ch * 2;
count *= (uint32_t)duration;
}
hdr.riff_sz = hdr.data_sz + 44 - 8;
if (write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
if (debug)
fprintf(stderr, "arec: cannot write header\n");
return -errno;
}
if (debug)
fprintf(stderr, "arec: %d ch, %d hz, %d bit, %s\n",
hdr.num_channels, hdr.sample_rate, hdr.bits_per_sample,
hdr.audio_format == FORMAT_PCM ? "PCM" : "unknown");
} else {
hdr.sample_rate = rate;
hdr.num_channels = ch;
}
if (!strncmp(fg, "M", sizeof("M"))) {
flag = PCM_MMAP;
} else if (!strncmp(fg, "N", sizeof("N"))) {
flag = PCM_NMMAP;
}
return record_file(hdr.sample_rate, hdr.num_channels, fd, count, flag, device);
}
static void signal_handler(int sig)
{
long file_size;
FILE *fp;
fprintf(stderr, "Arec:Aborted by signal %s...\n", strsignal(sig));
fprintf(stderr, "Arec:lseeked to %d", (int) lseek(fd, 0, SEEK_SET));
hdr.riff_sz = hdr.data_sz + 44 - 8;
fprintf(stderr, "Arec: hdr.data_sz =%d\n", hdr.data_sz);
fprintf(stderr, "Arec: hdr.riff_sz =%d\n", hdr.riff_sz);
if (write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
if (debug)
fprintf(stderr, "Arec:arec: cannot write header\n");
} else
fd = -1;
if (fd > 1) {
close(fd);
fd = -1;
}
free(filename);
free(data);
pcm = NULL;
raise(sig);
}
int main(int argc, char **argv)
{
int rate = 48000;
int ch = 1;
int i = 0;
int option_index = 0;
int c;
char *mmap = "N";
char *device = "hw:0,0";
struct sigaction sa;
int rc = 0;
if (argc < 2) {
printf("\nUsage: arec [options] <file>\n"
"options:\n"
"-D <hw:C,D> -- Alsa PCM by name\n"
"-M -- Mmap stream\n"
"-P -- Hostless steam[No PCM]\n"
"-V -- verbose\n"
"-C -- Channels\n"
"-R -- Rate\n"
"-T -- Time in seconds for recording\n"
"-F -- Format\n"
"-B -- Period\n"
"<file> \n");
for (i = 0; i < SNDRV_PCM_FORMAT_LAST; ++i)
if (get_format_name(i))
fprintf(stderr, "%s ", get_format_name(i));
fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
return 0;
}
while ((c = getopt_long(argc, argv, "PVMD:R:C:T:F:B:", long_options, &option_index)) != -1) {
switch (c) {
case 'P':
pcm_flag = 0;
break;
case 'V':
debug = 1;
break;
case 'M':
mmap = "M";
break;
case 'D':
device = optarg;
break;
case 'R':
rate = (int)strtol(optarg, NULL, 0);
break;
case 'C':
ch = (int)strtol(optarg, NULL, 0);
break;
case 'T':
duration = (int)strtol(optarg, NULL, 0);
break;
case 'F':
format = (int)get_format(optarg);
break;
case 'B':
period = (int)strtol(optarg, NULL, 0);
break;
default:
printf("\nUsage: arec [options] <file>\n"
"options:\n"
"-D <hw:C,D> -- Alsa PCM by name\n"
"-M -- Mmap stream\n"
"-P -- Hostless steam[No PCM]\n"
"-V -- verbose\n"
"-C -- Channels\n"
"-R -- Rate\n"
"-T -- Time in seconds for recording\n"
"-F -- Format\n"
"-B -- Period\n"
"<file> \n");
for (i = 0; i < SNDRV_PCM_FORMAT_LAST; ++i)
if (get_format_name(i))
fprintf(stderr, "%s ", get_format_name(i));
fprintf(stderr, "\nSome of these may not be available on selected hardware\n");
return -EINVAL;
}
}
filename = (char*) calloc(1, 30);
if (!filename) {
fprintf(stderr, "Arec:Failed to allocate filename!");
return -ENOMEM;
}
if (optind > argc - 1) {
free(filename);
filename = NULL;
} else {
strlcpy(filename, argv[optind++], 30);
}
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &signal_handler;
sigaction(SIGABRT, &sa, NULL);
if (pcm_flag) {
if (format == SNDRV_PCM_FORMAT_S16_LE)
rc = rec_wav(mmap, device, rate, ch, filename);
else
rc = rec_raw(mmap, device, rate, ch, filename);
} else {
rc = rec_wav(mmap, device, rate, ch, "dummy");
}
if (filename)
free(filename);
return rc;
}