/**

 * \file pcm/pcm_file.c

 * \ingroup PCM_Plugins

 * \brief PCM File Plugin Interface

 * \author Abramo Bagnara <abramo@alsa-project.org>

 * \date 2000-2001

 */

/*

 *  PCM - File plugin

 *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>

 *

 *

 *   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 <ctype.h>

#include <string.h>

#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 ssize_t safe_write(int fd, const void *buf, size_t len)

{

	while (1) {

		ssize_t r = write(fd, buf, len);

		if (r < 0) {

			if (errno == EINTR)

				continue;

			if (errno == EPIPE)

				return -EIO;

			return -errno;

		}

		return r;

	}

}

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 = safe_write(file->fd, header, sizeof(header));

	if (res != sizeof(header))

		goto write_error;

	res = safe_write(file->fd, &file->wav_header, sizeof(file->wav_header));

	if (res != sizeof(file->wav_header))

		goto write_error;

	res = safe_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 = safe_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 = safe_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 = safe_write(file->fd, file->wbuf + file->file_ptr_bytes, n);

		if (err < 0) {

			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