/** * \file pcm/pcm_file.c * \ingroup PCM_Plugins * \brief PCM File Plugin Interface * \author Abramo Bagnara * \date 2000-2001 */ /* * PCM - File plugin * Copyright (c) 2000 by Abramo Bagnara * * * This library is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "bswap.h" #include #include #include "pcm_local.h" #include "pcm_plugin.h" #ifndef PIC /* entry for static linking */ const char *_snd_module_pcm_file = ""; #endif #ifndef DOC_HIDDEN /* keys to be replaced by real values in the filename */ #define LEADING_KEY '%' /* i.e. %r, %c, %b ... */ #define RATE_KEY 'r' #define CHANNELS_KEY 'c' #define BWIDTH_KEY 'b' #define FORMAT_KEY 'f' /* maximum length of a value */ #define VALUE_MAXLEN 64 typedef enum _snd_pcm_file_format { SND_PCM_FILE_FORMAT_RAW, SND_PCM_FILE_FORMAT_WAV } snd_pcm_file_format_t; /* WAV format chunk */ struct wav_fmt { short fmt; short chan; int rate; int bps; short bwidth; short bits; }; typedef struct { snd_pcm_generic_t gen; char *fname; char *final_fname; int trunc; int perm; int fd; FILE *pipe; char *ifname; int ifd; int format; snd_pcm_uframes_t appl_ptr; snd_pcm_uframes_t file_ptr_bytes; snd_pcm_uframes_t wbuf_size; snd_pcm_uframes_t rbuf_size; size_t wbuf_size_bytes; size_t wbuf_used_bytes; char *wbuf; size_t rbuf_size_bytes; size_t rbuf_used_bytes; char *rbuf; snd_pcm_channel_area_t *wbuf_areas; size_t buffer_bytes; struct wav_fmt wav_header; size_t filelen; char ifmmap_overwritten; } snd_pcm_file_t; #if __BYTE_ORDER == __LITTLE_ENDIAN #define TO_LE32(x) (x) #define TO_LE16(x) (x) #else #define TO_LE32(x) bswap_32(x) #define TO_LE16(x) bswap_16(x) #endif static int snd_pcm_file_append_value(char **string_p, char **index_ch_p, int *len_p, const char *value) { char *string, *index_ch; int index, len, value_len; /* input pointer values */ len = *(len_p); string = *(string_p); index_ch = *(index_ch_p); value_len = strlen(value); /* reallocation to accommodate the value */ index = index_ch - string; len += value_len; string = realloc(string, len + 1); if (!string) return -ENOMEM; index_ch = string + index; /* concatenating the new value */ strcpy(index_ch, value); index_ch += value_len; /* return values */ *(len_p) = len; *(string_p) = string; *(index_ch_p) = index_ch; return 0; } static int snd_pcm_file_replace_fname(snd_pcm_file_t *file, char **new_fname_p) { char value[VALUE_MAXLEN]; char *fname = file->fname; char *new_fname = NULL; char *old_last_ch, *old_index_ch, *new_index_ch; int old_len, new_len, err; snd_pcm_t *pcm = file->gen.slave; /* we want to keep fname, const */ old_len = new_len = strlen(fname); old_last_ch = fname + old_len - 1; new_fname = malloc(new_len + 1); if (!new_fname) return -ENOMEM; old_index_ch = fname; /* first character of the old name */ new_index_ch = new_fname; /* first char of the new name */ while (old_index_ch <= old_last_ch) { if (*(old_index_ch) == LEADING_KEY && old_index_ch != old_last_ch) { /* is %, not last char, skipping and checking next char */ switch (*(++old_index_ch)) { case RATE_KEY: snprintf(value, sizeof(value), "%d", pcm->rate); err = snd_pcm_file_append_value(&new_fname, &new_index_ch, &new_len, value); if (err < 0) return err; break; case CHANNELS_KEY: snprintf(value, sizeof(value), "%d", pcm->channels); err = snd_pcm_file_append_value(&new_fname, &new_index_ch, &new_len, value); if (err < 0) return err; break; case BWIDTH_KEY: snprintf(value, sizeof(value), "%d", pcm->frame_bits/pcm->channels); err = snd_pcm_file_append_value(&new_fname, &new_index_ch, &new_len, value); if (err < 0) return err; break; case FORMAT_KEY: err = snd_pcm_file_append_value(&new_fname, &new_index_ch, &new_len, snd_pcm_format_name(pcm->format)); if (err < 0) return err; break; default: /* non-key char, just copying */ *(new_index_ch++) = *(old_index_ch); } /* next old char */ old_index_ch++; } else { /* plain copying, shifting both strings to next chars */ *(new_index_ch++) = *(old_index_ch++); } } /* closing the new string */ *(new_index_ch) = '\0'; *(new_fname_p) = new_fname; return 0; } static int snd_pcm_file_open_output_file(snd_pcm_file_t *file) { int err, fd; /* fname can contain keys, generating final_fname */ err = snd_pcm_file_replace_fname(file, &(file->final_fname)); if (err < 0) return err; /*printf("DEBUG - original fname: %s, final fname: %s\n", file->fname, file->final_fname);*/ if (file->final_fname[0] == '|') { /* pipe mode */ FILE *pipe; /* clearing */ pipe = popen(file->final_fname + 1, "w"); if (!pipe) { SYSERR("running %s for writing failed", file->final_fname); return -errno; } fd = fileno(pipe); file->pipe = pipe; } else { file->pipe = NULL; if (file->trunc) fd = open(file->final_fname, O_WRONLY|O_CREAT|O_TRUNC, file->perm); else { fd = open(file->final_fname, O_WRONLY|O_CREAT|O_EXCL, file->perm); if (fd < 0) { char *tmpfname = NULL; int idx, len; len = strlen(file->final_fname) + 6; tmpfname = malloc(len); if (!tmpfname) return -ENOMEM; for (idx = 1; idx < 10000; idx++) { snprintf(tmpfname, len, "%s.%04d", file->final_fname, idx); fd = open(tmpfname, O_WRONLY|O_CREAT|O_EXCL, file->perm); if (fd >= 0) { free(file->final_fname); file->final_fname = tmpfname; break; } } if (fd < 0) { SYSERR("open %s for writing failed", file->final_fname); free(tmpfname); return -errno; } } } } file->fd = fd; return 0; } /* fill areas with data from input file, return bytes red */ static int snd_pcm_file_areas_read_infile(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, snd_pcm_uframes_t frames) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_channel_area_t areas_if[pcm->channels]; ssize_t bytes; if (file->ifd < 0) return -EBADF; if (file->rbuf == NULL) return -ENOMEM; if (file->rbuf_size < frames) { SYSERR("requested more frames than pcm buffer"); return -ENOMEM; } bytes = snd_pcm_frames_to_bytes(pcm, frames); if (bytes < 0) return bytes; bytes = read(file->ifd, file->rbuf, bytes); if (bytes < 0) { SYSERR("read from file failed, error: %d", bytes); return bytes; } snd_pcm_areas_from_buf(pcm, areas_if, file->rbuf); snd_pcm_areas_copy(areas, offset, areas_if, 0, pcm->channels, snd_pcm_bytes_to_frames(pcm, bytes), pcm->format); return bytes; } static void setup_wav_header(snd_pcm_t *pcm, struct wav_fmt *fmt) { fmt->fmt = TO_LE16(0x01); fmt->chan = TO_LE16(pcm->channels); fmt->rate = TO_LE32(pcm->rate); fmt->bwidth = pcm->frame_bits / 8; fmt->bps = fmt->bwidth * pcm->rate; fmt->bits = snd_pcm_format_width(pcm->format); fmt->bps = TO_LE32(fmt->bps); fmt->bwidth = TO_LE16(fmt->bwidth); fmt->bits = TO_LE16(fmt->bits); } static int write_wav_header(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; ssize_t res; static const char header[] = { 'R', 'I', 'F', 'F', 0x24, 0, 0, 0, 'W', 'A', 'V', 'E', 'f', 'm', 't', ' ', 0x10, 0, 0, 0, }; static const char header2[] = { 'd', 'a', 't', 'a', 0, 0, 0, 0 }; setup_wav_header(pcm, &file->wav_header); res = write(file->fd, header, sizeof(header)); if (res != sizeof(header)) goto write_error; res = write(file->fd, &file->wav_header, sizeof(file->wav_header)); if (res != sizeof(file->wav_header)) goto write_error; res = write(file->fd, header2, sizeof(header2)); if (res != sizeof(header2)) goto write_error; return 0; write_error: /* * print real errno if available and return EIO, reason for this is * to block possible EPIPE in case file->fd is a pipe. EPIPE from * file->fd conflicts with EPIPE from playback stream which should * be used to signal XRUN on playback device */ if (res < 0) SYSERR("%s write header failed, file data may be corrupt", file->fname); else SNDERR("%s write header incomplete, file data may be corrupt", file->fname); memset(&file->wav_header, 0, sizeof(struct wav_fmt)); return -EIO; } /* fix up the length fields in WAV header */ static void fixup_wav_header(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; int len, ret; /* RIFF length */ if (lseek(file->fd, 4, SEEK_SET) == 4) { len = (file->filelen + 0x24) > 0x7fffffff ? 0x7fffffff : (int)(file->filelen + 0x24); len = TO_LE32(len); ret = write(file->fd, &len, 4); if (ret < 0) return; } /* data length */ if (lseek(file->fd, 0x28, SEEK_SET) == 0x28) { len = file->filelen > 0x7fffffff ? 0x7fffffff : (int)file->filelen; len = TO_LE32(len); ret = write(file->fd, &len, 4); if (ret < 0) return; } } #endif /* DOC_HIDDEN */ /* return error code in case write failed */ static int snd_pcm_file_write_bytes(snd_pcm_t *pcm, size_t bytes) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_sframes_t err = 0; assert(bytes <= file->wbuf_used_bytes); if (file->format == SND_PCM_FILE_FORMAT_WAV && !file->wav_header.fmt) { err = write_wav_header(pcm); if (err < 0) { file->wbuf_used_bytes = 0; file->file_ptr_bytes = 0; return err; } } while (bytes > 0) { size_t n = bytes; size_t cont = file->wbuf_size_bytes - file->file_ptr_bytes; if (n > cont) n = cont; err = write(file->fd, file->wbuf + file->file_ptr_bytes, n); if (err < 0) { err = -errno; file->wbuf_used_bytes = 0; file->file_ptr_bytes = 0; SYSERR("%s write failed, file data may be corrupt", file->fname); return err; } bytes -= err; file->wbuf_used_bytes -= err; file->file_ptr_bytes += err; if (file->file_ptr_bytes == file->wbuf_size_bytes) file->file_ptr_bytes = 0; file->filelen += err; if ((snd_pcm_uframes_t)err != n) break; } return 0; } static int snd_pcm_file_add_frames(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, snd_pcm_uframes_t frames) { snd_pcm_file_t *file = pcm->private_data; while (frames > 0) { int err = 0; snd_pcm_uframes_t n = frames; snd_pcm_uframes_t cont = file->wbuf_size - file->appl_ptr; snd_pcm_uframes_t avail = file->wbuf_size - snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes); if (n > cont) n = cont; if (n > avail) n = avail; snd_pcm_areas_copy(file->wbuf_areas, file->appl_ptr, areas, offset, pcm->channels, n, pcm->format); frames -= n; offset += n; file->appl_ptr += n; if (file->appl_ptr == file->wbuf_size) file->appl_ptr = 0; file->wbuf_used_bytes += snd_pcm_frames_to_bytes(pcm, n); if (file->wbuf_used_bytes > file->buffer_bytes) { err = snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes - file->buffer_bytes); if (err < 0) return err; } assert(file->wbuf_used_bytes < file->wbuf_size_bytes); } return 0; } static int snd_pcm_file_close(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; if (file->fname) { if (file->wav_header.fmt) fixup_wav_header(pcm); free((void *)file->fname); if (file->pipe) { pclose(file->pipe); } else if (file->fd >= 0) { close(file->fd); } } if (file->ifname) { free((void *)file->ifname); close(file->ifd); } return snd_pcm_generic_close(pcm); } static int snd_pcm_file_reset(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; int err = snd_pcm_reset(file->gen.slave); if (err >= 0) { /* FIXME: Questionable here */ snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes); assert(file->wbuf_used_bytes == 0); } return err; } static int snd_pcm_file_drop(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; int err = snd_pcm_drop(file->gen.slave); if (err >= 0) { /* FIXME: Questionable here */ snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes); assert(file->wbuf_used_bytes == 0); } return err; } /* locking */ static int snd_pcm_file_drain(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; int err = snd_pcm_drain(file->gen.slave); if (err >= 0) { __snd_pcm_lock(pcm); snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes); assert(file->wbuf_used_bytes == 0); __snd_pcm_unlock(pcm); } return err; } static snd_pcm_sframes_t snd_pcm_file_rewindable(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_sframes_t res = snd_pcm_rewindable(file->gen.slave); snd_pcm_sframes_t n = snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes); if (res > n) res = n; return res; } static snd_pcm_sframes_t snd_pcm_file_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_sframes_t err; snd_pcm_uframes_t n; n = snd_pcm_frames_to_bytes(pcm, frames); if (n > file->wbuf_used_bytes) frames = snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes); err = snd_pcm_rewind(file->gen.slave, frames); if (err > 0) { file->appl_ptr = (file->appl_ptr - err + file->wbuf_size) % file->wbuf_size; n = snd_pcm_frames_to_bytes(pcm, err); file->wbuf_used_bytes -= n; } return err; } static snd_pcm_sframes_t snd_pcm_file_forwardable(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_sframes_t res = snd_pcm_forwardable(file->gen.slave); snd_pcm_sframes_t n = snd_pcm_bytes_to_frames(pcm, file->wbuf_size_bytes - file->wbuf_used_bytes); if (res > n) res = n; return res; } static snd_pcm_sframes_t snd_pcm_file_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_sframes_t err; snd_pcm_uframes_t n; n = snd_pcm_frames_to_bytes(pcm, frames); if (file->wbuf_used_bytes + n > file->wbuf_size_bytes) frames = snd_pcm_bytes_to_frames(pcm, file->wbuf_size_bytes - file->wbuf_used_bytes); err = INTERNAL(snd_pcm_forward)(file->gen.slave, frames); if (err > 0) { file->appl_ptr = (file->appl_ptr + err) % file->wbuf_size; n = snd_pcm_frames_to_bytes(pcm, err); file->wbuf_used_bytes += n; } return err; } /* locking */ static snd_pcm_sframes_t snd_pcm_file_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_channel_area_t areas[pcm->channels]; snd_pcm_sframes_t n = _snd_pcm_writei(file->gen.slave, buffer, size); if (n > 0) { snd_pcm_areas_from_buf(pcm, areas, (void*) buffer); __snd_pcm_lock(pcm); if (snd_pcm_file_add_frames(pcm, areas, 0, n) < 0) { __snd_pcm_unlock(pcm); return -EIO; } __snd_pcm_unlock(pcm); } return n; } /* locking */ static snd_pcm_sframes_t snd_pcm_file_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_channel_area_t areas[pcm->channels]; snd_pcm_sframes_t n = _snd_pcm_writen(file->gen.slave, bufs, size); if (n > 0) { snd_pcm_areas_from_bufs(pcm, areas, bufs); __snd_pcm_lock(pcm); if (snd_pcm_file_add_frames(pcm, areas, 0, n) < 0) { __snd_pcm_unlock(pcm); return -EIO; } __snd_pcm_unlock(pcm); } return n; } /* locking */ static snd_pcm_sframes_t snd_pcm_file_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_channel_area_t areas[pcm->channels]; snd_pcm_sframes_t frames; frames = _snd_pcm_readi(file->gen.slave, buffer, size); if (frames <= 0) return frames; snd_pcm_areas_from_buf(pcm, areas, buffer); snd_pcm_file_areas_read_infile(pcm, areas, 0, frames); __snd_pcm_lock(pcm); if (snd_pcm_file_add_frames(pcm, areas, 0, frames) < 0) { __snd_pcm_unlock(pcm); return -EIO; } __snd_pcm_unlock(pcm); return frames; } /* locking */ static snd_pcm_sframes_t snd_pcm_file_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_channel_area_t areas[pcm->channels]; snd_pcm_sframes_t frames; frames = _snd_pcm_readn(file->gen.slave, bufs, size); if (frames <= 0) return frames; snd_pcm_areas_from_bufs(pcm, areas, bufs); snd_pcm_file_areas_read_infile(pcm, areas, 0, frames); __snd_pcm_lock(pcm); if (snd_pcm_file_add_frames(pcm, areas, 0, frames) < 0) { __snd_pcm_unlock(pcm); return -EIO; } __snd_pcm_unlock(pcm); return frames; } static snd_pcm_sframes_t snd_pcm_file_mmap_commit(snd_pcm_t *pcm, snd_pcm_uframes_t offset, snd_pcm_uframes_t size) { snd_pcm_file_t *file = pcm->private_data; snd_pcm_uframes_t ofs; snd_pcm_uframes_t siz = size; const snd_pcm_channel_area_t *areas; snd_pcm_sframes_t result; file->ifmmap_overwritten = 0; result = snd_pcm_mmap_begin(file->gen.slave, &areas, &ofs, &siz); if (result >= 0) { assert(ofs == offset && siz == size); result = snd_pcm_mmap_commit(file->gen.slave, ofs, siz); if (result > 0) { if (snd_pcm_file_add_frames(pcm, areas, ofs, result) < 0) return -EIO; } } return result; } static int snd_pcm_file_mmap_begin(snd_pcm_t *pcm, const snd_pcm_channel_area_t **areas, snd_pcm_uframes_t *offset, snd_pcm_uframes_t *frames) { snd_pcm_file_t *file = pcm->private_data; int result; result = snd_pcm_mmap_begin(file->gen.slave, areas, offset, frames); if (result < 0) return result; if (pcm->stream != SND_PCM_STREAM_CAPTURE) return result; /* user may run mmap_begin without mmap_commit multiple times in row */ if (file->ifmmap_overwritten) return result; file->ifmmap_overwritten = 1; snd_pcm_file_areas_read_infile(pcm, *areas, *offset, *frames); return result; } static int snd_pcm_file_hw_free(snd_pcm_t *pcm) { snd_pcm_file_t *file = pcm->private_data; free(file->wbuf); free(file->wbuf_areas); free(file->final_fname); free(file->rbuf); file->wbuf = NULL; file->wbuf_areas = NULL; file->final_fname = NULL; file->rbuf = NULL; return snd_pcm_hw_free(file->gen.slave); } static int snd_pcm_file_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params) { snd_pcm_file_t *file = pcm->private_data; unsigned int channel; snd_pcm_t *slave = file->gen.slave; int err = _snd_pcm_hw_params_internal(slave, params); if (err < 0) return err; file->buffer_bytes = snd_pcm_frames_to_bytes(slave, slave->buffer_size); file->wbuf_size = slave->buffer_size * 2; file->wbuf_size_bytes = snd_pcm_frames_to_bytes(slave, file->wbuf_size); file->wbuf_used_bytes = 0; file->ifmmap_overwritten = 0; assert(!file->wbuf); file->wbuf = malloc(file->wbuf_size_bytes); if (file->wbuf == NULL) { snd_pcm_file_hw_free(pcm); return -ENOMEM; } file->wbuf_areas = malloc(sizeof(*file->wbuf_areas) * slave->channels); if (file->wbuf_areas == NULL) { snd_pcm_file_hw_free(pcm); return -ENOMEM; } assert(!file->rbuf); file->rbuf_size = slave->buffer_size; file->rbuf_size_bytes = snd_pcm_frames_to_bytes(slave, file->rbuf_size); file->rbuf_used_bytes = 0; file->rbuf = malloc(file->rbuf_size_bytes); if (file->rbuf == NULL) { snd_pcm_file_hw_free(pcm); return -ENOMEM; } file->appl_ptr = file->file_ptr_bytes = 0; for (channel = 0; channel < slave->channels; ++channel) { snd_pcm_channel_area_t *a = &file->wbuf_areas[channel]; a->addr = file->wbuf; a->first = slave->sample_bits * channel; a->step = slave->frame_bits; } if (file->fd < 0) { err = snd_pcm_file_open_output_file(file); if (err < 0) { SYSERR("failed opening output file %s", file->fname); return err; } } /* pointer may have changed - e.g if plug is used. */ snd_pcm_unlink_hw_ptr(pcm, file->gen.slave); snd_pcm_unlink_appl_ptr(pcm, file->gen.slave); snd_pcm_link_hw_ptr(pcm, file->gen.slave); snd_pcm_link_appl_ptr(pcm, file->gen.slave); return 0; } static void snd_pcm_file_dump(snd_pcm_t *pcm, snd_output_t *out) { snd_pcm_file_t *file = pcm->private_data; if (file->fname) snd_output_printf(out, "File PCM (file=%s)\n", file->fname); else snd_output_printf(out, "File PCM (fd=%d)\n", file->fd); if (file->final_fname) snd_output_printf(out, "Final file PCM (file=%s)\n", file->final_fname); if (pcm->setup) { snd_output_printf(out, "Its setup is:\n"); snd_pcm_dump_setup(pcm, out); } snd_output_printf(out, "Slave: "); snd_pcm_dump(file->gen.slave, out); } static const snd_pcm_ops_t snd_pcm_file_ops = { .close = snd_pcm_file_close, .info = snd_pcm_generic_info, .hw_refine = snd_pcm_generic_hw_refine, .hw_params = snd_pcm_file_hw_params, .hw_free = snd_pcm_file_hw_free, .sw_params = snd_pcm_generic_sw_params, .channel_info = snd_pcm_generic_channel_info, .dump = snd_pcm_file_dump, .nonblock = snd_pcm_generic_nonblock, .async = snd_pcm_generic_async, .mmap = snd_pcm_generic_mmap, .munmap = snd_pcm_generic_munmap, .query_chmaps = snd_pcm_generic_query_chmaps, .get_chmap = snd_pcm_generic_get_chmap, .set_chmap = snd_pcm_generic_set_chmap, }; static const snd_pcm_fast_ops_t snd_pcm_file_fast_ops = { .status = snd_pcm_generic_status, .state = snd_pcm_generic_state, .hwsync = snd_pcm_generic_hwsync, .delay = snd_pcm_generic_delay, .prepare = snd_pcm_generic_prepare, .reset = snd_pcm_file_reset, .start = snd_pcm_generic_start, .drop = snd_pcm_file_drop, .drain = snd_pcm_file_drain, .pause = snd_pcm_generic_pause, .rewindable = snd_pcm_file_rewindable, .rewind = snd_pcm_file_rewind, .forwardable = snd_pcm_file_forwardable, .forward = snd_pcm_file_forward, .resume = snd_pcm_generic_resume, .link = snd_pcm_generic_link, .link_slaves = snd_pcm_generic_link_slaves, .unlink = snd_pcm_generic_unlink, .writei = snd_pcm_file_writei, .writen = snd_pcm_file_writen, .readi = snd_pcm_file_readi, .readn = snd_pcm_file_readn, .avail_update = snd_pcm_generic_avail_update, .mmap_commit = snd_pcm_file_mmap_commit, .poll_descriptors_count = snd_pcm_generic_poll_descriptors_count, .poll_descriptors = snd_pcm_generic_poll_descriptors, .poll_revents = snd_pcm_generic_poll_revents, .htimestamp = snd_pcm_generic_htimestamp, .mmap_begin = snd_pcm_file_mmap_begin, }; /** * \brief Creates a new File PCM * \param pcmp Returns created PCM handle * \param name Name of PCM * \param fname Output filename (or NULL if file descriptor fd is available) * \param fd Output file descriptor * \param ifname Input filename (or NULL if file descriptor ifd is available) * \param ifd Input file descriptor (if (ifd < 0) && (ifname == NULL), no input * redirection will be performed) * \param trunc Truncate the file if it already exists * \param fmt File format ("raw" or "wav" are available) * \param perm File permission * \param slave Slave PCM handle * \param close_slave When set, the slave PCM handle is closed with copy PCM * \param stream the direction of PCM stream * \retval zero on success otherwise a negative error code * \warning Using of this function might be dangerous in the sense * of compatibility reasons. The prototype might be freely * changed in future. */ int snd_pcm_file_open(snd_pcm_t **pcmp, const char *name, const char *fname, int fd, const char *ifname, int ifd, int trunc, const char *fmt, int perm, snd_pcm_t *slave, int close_slave, snd_pcm_stream_t stream) { snd_pcm_t *pcm; snd_pcm_file_t *file; snd_pcm_file_format_t format; struct timespec timespec; int err; assert(pcmp); if (fmt == NULL || strcmp(fmt, "raw") == 0) format = SND_PCM_FILE_FORMAT_RAW; else if (!strcmp(fmt, "wav")) format = SND_PCM_FILE_FORMAT_WAV; else { SNDERR("file format %s is unknown", fmt); return -EINVAL; } file = calloc(1, sizeof(snd_pcm_file_t)); if (!file) { return -ENOMEM; } /* opening output fname is delayed until writing, when PCM params are known */ if (fname) file->fname = strdup(fname); file->trunc = trunc; file->perm = perm; if (ifname && (stream == SND_PCM_STREAM_CAPTURE)) { ifd = open(ifname, O_RDONLY); /* TODO: mind blocking mode */ if (ifd < 0) { SYSERR("open %s for reading failed", ifname); free(file->fname); free(file); return -errno; } file->ifname = strdup(ifname); } file->fd = fd; file->ifd = ifd; file->format = format; file->gen.slave = slave; file->gen.close_slave = close_slave; err = snd_pcm_new(&pcm, SND_PCM_TYPE_FILE, name, slave->stream, slave->mode); if (err < 0) { free(file->fname); free(file->ifname); free(file); return err; } pcm->ops = &snd_pcm_file_ops; pcm->fast_ops = &snd_pcm_file_fast_ops; pcm->private_data = file; pcm->poll_fd = slave->poll_fd; pcm->poll_events = slave->poll_events; pcm->mmap_shadow = 1; pcm->tstamp_type = SND_PCM_TSTAMP_TYPE_GETTIMEOFDAY; #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) if (clock_gettime(CLOCK_MONOTONIC, ×pec) == 0) pcm->tstamp_type = SND_PCM_TSTAMP_TYPE_MONOTONIC; #endif pcm->stream = stream; snd_pcm_link_hw_ptr(pcm, slave); snd_pcm_link_appl_ptr(pcm, slave); *pcmp = pcm; return 0; } /*! \page pcm_plugins \section pcm_plugins_file Plugin: File This plugin stores contents of a PCM stream to file or pipes the stream to a command, and optionally uses an existing file as an input data source (i.e., "virtual mic") \code pcm.name { type file # File PCM slave STR # Slave name # or slave { # Slave definition pcm STR # Slave PCM name # or pcm { } # Slave PCM definition } file STR # Output filename (or shell command the stream # will be piped to if STR starts with the pipe # char). # STR can contain format keys, replaced by # real values corresponding to the stream: # %r rate (replaced with: 48000) # %c channels (replaced with: 2) # %b bits per sample (replaced with: 16) # %f sample format string # (replaced with: S16_LE) # %% replaced with % or file INT # Output file descriptor number infile STR # Input filename - only raw format or infile INT # Input file descriptor number [format STR] # File format ("raw" or "wav") [perm INT] # Output file permission (octal, def. 0600) } \endcode \subsection pcm_plugins_file_funcref Function reference
  • snd_pcm_file_open()
  • _snd_pcm_file_open()
*/ /** * \brief Creates a new File PCM * \param pcmp Returns created PCM handle * \param name Name of PCM * \param root Root configuration node * \param conf Configuration node with File PCM description * \param stream Stream type * \param mode Stream mode * \retval zero on success otherwise a negative error code * \warning Using of this function might be dangerous in the sense * of compatibility reasons. The prototype might be freely * changed in future. */ int _snd_pcm_file_open(snd_pcm_t **pcmp, const char *name, snd_config_t *root, snd_config_t *conf, snd_pcm_stream_t stream, int mode) { snd_config_iterator_t i, next; int err; snd_pcm_t *spcm; snd_config_t *slave = NULL, *sconf; const char *fname = NULL, *ifname = NULL; const char *format = NULL; long fd = -1, ifd = -1, trunc = 1; long perm = 0600; snd_config_for_each(i, next, conf) { snd_config_t *n = snd_config_iterator_entry(i); const char *id; if (snd_config_get_id(n, &id) < 0) continue; if (snd_pcm_conf_generic_id(id)) continue; if (strcmp(id, "slave") == 0) { slave = n; continue; } if (strcmp(id, "format") == 0) { err = snd_config_get_string(n, &format); if (err < 0) { SNDERR("Invalid type for %s", id); return -EINVAL; } continue; } if (strcmp(id, "file") == 0) { err = snd_config_get_string(n, &fname); if (err < 0) { err = snd_config_get_integer(n, &fd); if (err < 0) { SNDERR("Invalid type for %s", id); return -EINVAL; } } continue; } if (strcmp(id, "infile") == 0) { err = snd_config_get_string(n, &ifname); if (err < 0) { err = snd_config_get_integer(n, &ifd); if (err < 0) { SNDERR("Invalid type for %s", id); return -EINVAL; } } continue; } if (strcmp(id, "perm") == 0) { err = snd_config_get_integer(n, &perm); if (err < 0) { SNDERR("Invalid type for %s", id); return err; } if ((perm & ~0777) != 0) { SNDERR("The field perm must be a valid file permission"); return -EINVAL; } continue; } if (strcmp(id, "truncate") == 0) { err = snd_config_get_bool(n); if (err < 0) return -EINVAL; trunc = err; continue; } SNDERR("Unknown field %s", id); return -EINVAL; } if (!format) { snd_config_t *n; /* read defaults */ if (snd_config_search(root, "defaults.pcm.file_format", &n) >= 0) { err = snd_config_get_string(n, &format); if (err < 0) { SNDERR("Invalid file format"); return -EINVAL; } } } if (!slave) { SNDERR("slave is not defined"); return -EINVAL; } err = snd_pcm_slave_conf(root, slave, &sconf, 0); if (err < 0) return err; if ((!fname || strlen(fname) == 0) && fd < 0) { snd_config_delete(sconf); SNDERR("file is not defined"); return -EINVAL; } err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf); snd_config_delete(sconf); if (err < 0) return err; err = snd_pcm_file_open(pcmp, name, fname, fd, ifname, ifd, trunc, format, perm, spcm, 1, stream); if (err < 0) snd_pcm_close(spcm); return err; } #ifndef DOC_HIDDEN SND_DLSYM_BUILD_VERSION(_snd_pcm_file_open, SND_PCM_DLSYM_VERSION); #endif