Lines Matching refs:file
2 * \file pcm/pcm_file.c
146 static int snd_pcm_file_replace_fname(snd_pcm_file_t *file, char **new_fname_p)
149 char *fname = file->fname;
154 snd_pcm_t *pcm = file->gen.slave;
225 static int snd_pcm_file_open_output_file(snd_pcm_file_t *file)
230 err = snd_pcm_file_replace_fname(file, &(file->final_fname));
234 file->fname, file->final_fname);*/
236 if (file->final_fname[0] == '|') {
240 pipe = popen(file->final_fname + 1, "w");
243 file->final_fname);
247 file->pipe = pipe;
249 file->pipe = NULL;
250 if (file->trunc)
251 fd = open(file->final_fname, O_WRONLY|O_CREAT|O_TRUNC,
252 file->perm);
254 fd = open(file->final_fname, O_WRONLY|O_CREAT|O_EXCL,
255 file->perm);
259 len = strlen(file->final_fname) + 6;
265 "%s.%04d", file->final_fname,
269 file->perm);
271 free(file->final_fname);
272 file->final_fname = tmpfname;
278 file->final_fname);
285 file->fd = fd;
289 /* fill areas with data from input file, return bytes red */
295 snd_pcm_file_t *file = pcm->private_data;
299 if (file->ifd < 0)
302 if (file->rbuf == NULL)
305 if (file->rbuf_size < frames) {
313 bytes = read(file->ifd, file->rbuf, bytes);
315 SYSERR("read from file failed, error: %d", bytes);
319 snd_pcm_areas_from_buf(pcm, areas_if, file->rbuf);
340 snd_pcm_file_t *file = pcm->private_data;
355 setup_wav_header(pcm, &file->wav_header);
357 res = safe_write(file->fd, header, sizeof(header));
361 res = safe_write(file->fd, &file->wav_header, sizeof(file->wav_header));
362 if (res != sizeof(file->wav_header))
365 res = safe_write(file->fd, header2, sizeof(header2));
374 * to block possible EPIPE in case file->fd is a pipe. EPIPE from
375 * file->fd conflicts with EPIPE from playback stream which should
379 SYSERR("%s write header failed, file data may be corrupt", file->fname);
381 SNDERR("%s write header incomplete, file data may be corrupt", file->fname);
383 memset(&file->wav_header, 0, sizeof(struct wav_fmt));
391 snd_pcm_file_t *file = pcm->private_data;
395 if (lseek(file->fd, 4, SEEK_SET) == 4) {
396 len = (file->filelen + 0x24) > 0x7fffffff ?
397 0x7fffffff : (int)(file->filelen + 0x24);
399 ret = safe_write(file->fd, &len, 4);
404 if (lseek(file->fd, 0x28, SEEK_SET) == 0x28) {
405 len = file->filelen > 0x7fffffff ?
406 0x7fffffff : (int)file->filelen;
408 ret = safe_write(file->fd, &len, 4);
420 snd_pcm_file_t *file = pcm->private_data;
422 assert(bytes <= file->wbuf_used_bytes);
424 if (file->format == SND_PCM_FILE_FORMAT_WAV &&
425 !file->wav_header.fmt) {
428 file->wbuf_used_bytes = 0;
429 file->file_ptr_bytes = 0;
436 size_t cont = file->wbuf_size_bytes - file->file_ptr_bytes;
439 err = safe_write(file->fd, file->wbuf + file->file_ptr_bytes, n);
441 file->wbuf_used_bytes = 0;
442 file->file_ptr_bytes = 0;
443 SYSERR("%s write failed, file data may be corrupt", file->fname);
447 file->wbuf_used_bytes -= err;
448 file->file_ptr_bytes += err;
449 if (file->file_ptr_bytes == file->wbuf_size_bytes)
450 file->file_ptr_bytes = 0;
451 file->filelen += err;
463 snd_pcm_file_t *file = pcm->private_data;
467 snd_pcm_uframes_t cont = file->wbuf_size - file->appl_ptr;
468 snd_pcm_uframes_t avail = file->wbuf_size - snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes);
473 snd_pcm_areas_copy(file->wbuf_areas, file->appl_ptr,
478 file->appl_ptr += n;
479 if (file->appl_ptr == file->wbuf_size)
480 file->appl_ptr = 0;
481 file->wbuf_used_bytes += snd_pcm_frames_to_bytes(pcm, n);
482 if (file->wbuf_used_bytes > file->buffer_bytes) {
483 err = snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes - file->buffer_bytes);
487 assert(file->wbuf_used_bytes < file->wbuf_size_bytes);
494 snd_pcm_file_t *file = pcm->private_data;
495 if (file->fname) {
496 if (file->wav_header.fmt)
498 free((void *)file->fname);
499 if (file->pipe) {
500 pclose(file->pipe);
501 } else if (file->fd >= 0) {
502 close(file->fd);
505 if (file->ifname) {
506 free((void *)file->ifname);
507 close(file->ifd);
514 snd_pcm_file_t *file = pcm->private_data;
515 int err = snd_pcm_reset(file->gen.slave);
518 snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes);
519 assert(file->wbuf_used_bytes == 0);
526 snd_pcm_file_t *file = pcm->private_data;
527 int err = snd_pcm_drop(file->gen.slave);
530 snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes);
531 assert(file->wbuf_used_bytes == 0);
539 snd_pcm_file_t *file = pcm->private_data;
540 int err = snd_pcm_drain(file->gen.slave);
543 snd_pcm_file_write_bytes(pcm, file->wbuf_used_bytes);
544 assert(file->wbuf_used_bytes == 0);
552 snd_pcm_file_t *file = pcm->private_data;
553 snd_pcm_sframes_t res = snd_pcm_rewindable(file->gen.slave);
554 snd_pcm_sframes_t n = snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes);
562 snd_pcm_file_t *file = pcm->private_data;
567 if (n > file->wbuf_used_bytes)
568 frames = snd_pcm_bytes_to_frames(pcm, file->wbuf_used_bytes);
569 err = snd_pcm_rewind(file->gen.slave, frames);
571 file->appl_ptr = (file->appl_ptr - err + file->wbuf_size) % file->wbuf_size;
573 file->wbuf_used_bytes -= n;
580 snd_pcm_file_t *file = pcm->private_data;
581 snd_pcm_sframes_t res = snd_pcm_forwardable(file->gen.slave);
582 snd_pcm_sframes_t n = snd_pcm_bytes_to_frames(pcm, file->wbuf_size_bytes - file->wbuf_used_bytes);
590 snd_pcm_file_t *file = pcm->private_data;
595 if (file->wbuf_used_bytes + n > file->wbuf_size_bytes)
596 frames = snd_pcm_bytes_to_frames(pcm, file->wbuf_size_bytes - file->wbuf_used_bytes);
597 err = INTERNAL(snd_pcm_forward)(file->gen.slave, frames);
599 file->appl_ptr = (file->appl_ptr + err) % file->wbuf_size;
601 file->wbuf_used_bytes += n;
609 snd_pcm_file_t *file = pcm->private_data;
611 snd_pcm_sframes_t n = _snd_pcm_writei(file->gen.slave, buffer, size);
627 snd_pcm_file_t *file = pcm->private_data;
629 snd_pcm_sframes_t n = _snd_pcm_writen(file->gen.slave, bufs, size);
645 snd_pcm_file_t *file = pcm->private_data;
649 frames = _snd_pcm_readi(file->gen.slave, buffer, size);
669 snd_pcm_file_t *file = pcm->private_data;
673 frames = _snd_pcm_readn(file->gen.slave, bufs, size);
694 snd_pcm_file_t *file = pcm->private_data;
700 file->ifmmap_overwritten = 0;
702 result = snd_pcm_mmap_begin(file->gen.slave, &areas, &ofs, &siz);
705 result = snd_pcm_mmap_commit(file->gen.slave, ofs, siz);
717 snd_pcm_file_t *file = pcm->private_data;
720 result = snd_pcm_mmap_begin(file->gen.slave, areas, offset, frames);
728 if (file->ifmmap_overwritten)
730 file->ifmmap_overwritten = 1;
739 snd_pcm_file_t *file = pcm->private_data;
740 free(file->wbuf);
741 free(file->wbuf_areas);
742 free(file->final_fname);
743 free(file->rbuf);
744 file->wbuf = NULL;
745 file->wbuf_areas = NULL;
746 file->final_fname = NULL;
747 file->rbuf = NULL;
748 return snd_pcm_hw_free(file->gen.slave);
753 snd_pcm_file_t *file = pcm->private_data;
755 snd_pcm_t *slave = file->gen.slave;
759 file->buffer_bytes = snd_pcm_frames_to_bytes(slave, slave->buffer_size);
760 file->wbuf_size = slave->buffer_size * 2;
761 file->wbuf_size_bytes = snd_pcm_frames_to_bytes(slave, file->wbuf_size);
762 file->wbuf_used_bytes = 0;
763 file->ifmmap_overwritten = 0;
764 assert(!file->wbuf);
765 file->wbuf = malloc(file->wbuf_size_bytes);
766 if (file->wbuf == NULL) {
770 file->wbuf_areas = malloc(sizeof(*file->wbuf_areas) * slave->channels);
771 if (file->wbuf_areas == NULL) {
775 assert(!file->rbuf);
776 file->rbuf_size = slave->buffer_size;
777 file->rbuf_size_bytes = snd_pcm_frames_to_bytes(slave, file->rbuf_size);
778 file->rbuf_used_bytes = 0;
779 file->rbuf = malloc(file->rbuf_size_bytes);
780 if (file->rbuf == NULL) {
784 file->appl_ptr = file->file_ptr_bytes = 0;
786 snd_pcm_channel_area_t *a = &file->wbuf_areas[channel];
787 a->addr = file->wbuf;
791 if (file->fd < 0) {
792 err = snd_pcm_file_open_output_file(file);
794 SYSERR("failed opening output file %s", file->fname);
800 snd_pcm_unlink_hw_ptr(pcm, file->gen.slave);
801 snd_pcm_unlink_appl_ptr(pcm, file->gen.slave);
803 snd_pcm_link_hw_ptr(pcm, file->gen.slave);
804 snd_pcm_link_appl_ptr(pcm, file->gen.slave);
811 snd_pcm_file_t *file = pcm->private_data;
812 if (file->fname)
813 snd_output_printf(out, "File PCM (file=%s)\n", file->fname);
815 snd_output_printf(out, "File PCM (fd=%d)\n", file->fd);
816 if (file->final_fname)
817 snd_output_printf(out, "Final file PCM (file=%s)\n",
818 file->final_fname);
825 snd_pcm_dump(file->gen.slave, out);
882 * \param fname Output filename (or NULL if file descriptor fd is available)
883 * \param fd Output file descriptor
884 * \param ifname Input filename (or NULL if file descriptor ifd is available)
885 * \param ifd Input file descriptor (if (ifd < 0) && (ifname == NULL), no input
887 * \param trunc Truncate the file if it already exists
905 snd_pcm_file_t *file;
917 SNDERR("file format %s is unknown", fmt);
920 file = calloc(1, sizeof(snd_pcm_file_t));
921 if (!file) {
928 file->fname = strdup(fname);
929 file->trunc = trunc;
930 file->perm = perm;
936 free(file->fname);
937 free(file);
940 file->ifname = strdup(ifname);
942 file->fd = fd;
943 file->ifd = ifd;
944 file->format = format;
945 file->gen.slave = slave;
946 file->gen.close_slave = close_slave;
950 free(file->fname);
951 free(file->ifname);
952 free(file);
957 pcm->private_data = file;
977 This plugin stores contents of a PCM stream to file or pipes the stream
978 to a command, and optionally uses an existing file as an input data source
983 type file # File PCM
991 file STR # Output filename (or shell command the stream
1003 file INT # Output file descriptor number
1006 infile INT # Input file descriptor number
1008 [perm INT] # Output file permission (octal, def. 0600)
1065 if (strcmp(id, "file") == 0) {
1094 SNDERR("The field perm must be a valid file permission");
1115 SNDERR("Invalid file format");
1129 SNDERR("file is not defined");