ericonr/sndio
1
0
Fork 0
mirror of https://github.com/ericonr/sndio.git synced 2024-02-18 04:45:21 -06:00
Code Issues Projects Releases Wiki Activity

s/wav/afile/

Browse Source
This commit is contained in:
Alexandre Ratchov 2015-01-05 18:01:29 +01:00
parent 7e4b5c54d9
commit 1341ff77a4
5 changed files with 157 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
aucat/Makefile.in
View File

@ -42,7 +42,7 @@ clean:
# ---------------------------------------------------------- dependencies --- # ---------------------------------------------------------- dependencies ---
OBJS = abuf.o aucat.o dsp.o utils.o wav.o OBJS = abuf.o afile.o aucat.o dsp.o utils.o
aucat: ${OBJS} aucat: ${OBJS}
${CC} ${LDFLAGS} ${LIB} -o aucat ${OBJS} ${LDADD} ${CC} ${LDFLAGS} ${LIB} -o aucat ${OBJS} ${LDADD}
@ -51,8 +51,8 @@ aucat: ${OBJS}
${CC} ${CFLAGS} ${INCLUDE} ${DEFS} -c $< ${CC} ${CFLAGS} ${INCLUDE} ${DEFS} -c $<
abuf.o: abuf.c abuf.h utils.h abuf.o: abuf.c abuf.h utils.h
aucat.o: aucat.c abuf.h dsp.h defs.h sysex.h utils.h wav.h \ afile.o: afile.c afile.h dsp.h defs.h utils.h
aucat.o: aucat.c abuf.h afile.h dsp.h defs.h sysex.h utils.h \
../bsd-compat/bsd-compat.h ../bsd-compat/bsd-compat.h
dsp.o: dsp.c dsp.h defs.h utils.h dsp.o: dsp.c dsp.h defs.h utils.h
utils.o: utils.c utils.h utils.o: utils.c utils.h
wav.o: wav.c utils.h wav.h dsp.h defs.h

232
aucat/wav.c → aucat/afile.c
View File

@ -19,8 +19,8 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include "afile.h"
#include "utils.h" #include "utils.h"
#include "wav.h"
/* /*
* Max size of a .wav file, format design limitation. * Max size of a .wav file, format design limitation.
@ -122,7 +122,7 @@ le32_set(le32_t *p, unsigned int v)
} }
static int static int
wav_readfmt(struct wav *w, unsigned int csize) afile_wav_readfmt(struct afile *f, unsigned int csize)
{ {
struct wavfmt fmt; struct wavfmt fmt;
unsigned int nch, rate, bits, bps, enc; unsigned int nch, rate, bits, bps, enc;
@ -134,7 +134,7 @@ wav_readfmt(struct wav *w, unsigned int csize)
} }
if (csize > WAV_FMT_EXT_SIZE) if (csize > WAV_FMT_EXT_SIZE)
csize = WAV_FMT_EXT_SIZE; csize = WAV_FMT_EXT_SIZE;
if (read(w->fd, &fmt, csize) != csize) { if (read(f->fd, &fmt, csize) != csize) {
log_puts("failed to read .wav format chun\n"); log_puts("failed to read .wav format chun\n");
return 0; return 0;
} }
@ -176,61 +176,61 @@ wav_readfmt(struct wav *w, unsigned int csize)
} }
switch (enc) { switch (enc) {
case WAV_FMT_PCM: case WAV_FMT_PCM:
w->enc = ENC_PCM; f->enc = ENC_PCM;
w->par.bps = bps; f->par.bps = bps;
w->par.bits = bits; f->par.bits = bits;
w->par.le = 1; f->par.le = 1;
w->par.sig = (bits <= 8) ? 0 : 1; /* ask microsoft why... */ f->par.sig = (bits <= 8) ? 0 : 1; /* ask microsoft why... */
w->par.msb = 1; f->par.msb = 1;
break; break;
case WAV_FMT_ALAW: case WAV_FMT_ALAW:
case WAV_FMT_ULAW: case WAV_FMT_ULAW:
w->enc = (enc == WAV_FMT_ULAW) ? ENC_ULAW : ENC_ALAW; f->enc = (enc == WAV_FMT_ULAW) ? ENC_ULAW : ENC_ALAW;
if (bits != 8) { if (bits != 8) {
log_puts("mulaw/alaw encoding not 8-bit\n"); log_puts("mulaw/alaw encoding not 8-bit\n");
return 0; return 0;
} }
w->par.bits = 8; f->par.bits = 8;
w->par.bps = 1; f->par.bps = 1;
w->par.le = ADATA_LE; f->par.le = ADATA_LE;
w->par.sig = 0; f->par.sig = 0;
w->par.msb = 0; f->par.msb = 0;
break; break;
case WAV_FMT_FLOAT: case WAV_FMT_FLOAT:
w->enc = ENC_FLOAT; f->enc = ENC_FLOAT;
if (bits != 32) { if (bits != 32) {
log_puts("only 32-bit float supported\n"); log_puts("only 32-bit float supported\n");
return 0; return 0;
} }
w->par.bits = 32; f->par.bits = 32;
w->par.bps = 4; f->par.bps = 4;
w->par.le = 1; f->par.le = 1;
w->par.sig = 0; f->par.sig = 0;
w->par.msb = 0; f->par.msb = 0;
break; break;
default: default:
log_putu(enc); log_putu(enc);
log_puts(": unsupported encoding in .wav file\n"); log_puts(": unsupported encoding in .wav file\n");
return 0; return 0;
} }
w->nch = nch; f->nch = nch;
w->rate = rate; f->rate = rate;
return 1; return 1;
} }
static int static int
wav_readhdr(struct wav *w) afile_wav_readhdr(struct afile *f)
{ {
struct wavriff riff; struct wavriff riff;
struct wavchunk chunk; struct wavchunk chunk;
unsigned int csize, rsize, pos = 0; unsigned int csize, rsize, pos = 0;
int fmt_done = 0; int fmt_done = 0;
if (lseek(w->fd, 0, SEEK_SET) < 0) { if (lseek(f->fd, 0, SEEK_SET) < 0) {
log_puts("failed to seek to beginning of .wav file\n"); log_puts("failed to seek to beginning of .wav file\n");
return 0; return 0;
} }
if (read(w->fd, &riff, sizeof(riff)) != sizeof(riff)) { if (read(f->fd, &riff, sizeof(riff)) != sizeof(riff)) {
log_puts("failed to read .wav file riff header\n"); log_puts("failed to read .wav file riff header\n");
return 0; return 0;
} }
@ -245,18 +245,18 @@ wav_readhdr(struct wav *w)
log_puts("missing data chunk in .wav file\n"); log_puts("missing data chunk in .wav file\n");
return 0; return 0;
} }
if (read(w->fd, &chunk, sizeof(chunk)) != sizeof(chunk)) { if (read(f->fd, &chunk, sizeof(chunk)) != sizeof(chunk)) {
log_puts("failed to read .wav chunk header\n"); log_puts("failed to read .wav chunk header\n");
return 0; return 0;
} }
csize = le32_get(&chunk.size); csize = le32_get(&chunk.size);
if (memcmp(chunk.id, wav_id_fmt, 4) == 0) { if (memcmp(chunk.id, wav_id_fmt, 4) == 0) {
if (!wav_readfmt(w, csize)) if (!afile_wav_readfmt(f, csize))
return 0; return 0;
fmt_done = 1; fmt_done = 1;
} else if (memcmp(chunk.id, wav_id_data, 4) == 0) { } else if (memcmp(chunk.id, wav_id_data, 4) == 0) {
w->startpos = pos + sizeof(riff) + sizeof(chunk); f->startpos = pos + sizeof(riff) + sizeof(chunk);
w->endpos = w->startpos + csize; f->endpos = f->startpos + csize;
break; break;
} else { } else {
#ifdef DEBUG #ifdef DEBUG
@ -269,7 +269,7 @@ wav_readhdr(struct wav *w)
* next chunk * next chunk
*/ */
pos += sizeof(struct wavchunk) + csize; pos += sizeof(struct wavchunk) + csize;
if (lseek(w->fd, sizeof(riff) + pos, SEEK_SET) < 0) { if (lseek(f->fd, sizeof(riff) + pos, SEEK_SET) < 0) {
log_puts("filed to seek to chunk in .wav file\n"); log_puts("filed to seek to chunk in .wav file\n");
return 0; return 0;
} }
@ -285,49 +285,49 @@ wav_readhdr(struct wav *w)
* Write header and seek to start position * Write header and seek to start position
*/ */
static int static int
wav_writehdr(struct wav *w) afile_wav_writehdr(struct afile *f)
{ {
struct wavhdr hdr; struct wavhdr hdr;
memset(&hdr, 0, sizeof(struct wavhdr)); memset(&hdr, 0, sizeof(struct wavhdr));
memcpy(hdr.riff.magic, wav_id_riff, 4); memcpy(hdr.riff.magic, wav_id_riff, 4);
memcpy(hdr.riff.type, wav_id_wave, 4); memcpy(hdr.riff.type, wav_id_wave, 4);
le32_set(&hdr.riff.size, w->endpos - sizeof(hdr.riff)); le32_set(&hdr.riff.size, f->endpos - sizeof(hdr.riff));
memcpy(hdr.fmt_hdr.id, wav_id_fmt, 4); memcpy(hdr.fmt_hdr.id, wav_id_fmt, 4);
le32_set(&hdr.fmt_hdr.size, sizeof(hdr.fmt)); le32_set(&hdr.fmt_hdr.size, sizeof(hdr.fmt));
le16_set(&hdr.fmt.fmt, 1); le16_set(&hdr.fmt.fmt, 1);
le16_set(&hdr.fmt.nch, w->nch); le16_set(&hdr.fmt.nch, f->nch);
le32_set(&hdr.fmt.rate, w->rate); le32_set(&hdr.fmt.rate, f->rate);
le32_set(&hdr.fmt.byterate, w->rate * w->par.bps * w->nch); le32_set(&hdr.fmt.byterate, f->rate * f->par.bps * f->nch);
le16_set(&hdr.fmt.blkalign, w->par.bps * w->nch); le16_set(&hdr.fmt.blkalign, f->par.bps * f->nch);
le16_set(&hdr.fmt.bits, w->par.bits); le16_set(&hdr.fmt.bits, f->par.bits);
memcpy(hdr.data_hdr.id, wav_id_data, 4); memcpy(hdr.data_hdr.id, wav_id_data, 4);
le32_set(&hdr.data_hdr.size, w->endpos - w->startpos); le32_set(&hdr.data_hdr.size, f->endpos - f->startpos);
if (lseek(w->fd, 0, SEEK_SET) < 0) { if (lseek(f->fd, 0, SEEK_SET) < 0) {
log_puts("failed to seek back to .wav file header\n"); log_puts("failed to seek back to .wav file header\n");
return 0; return 0;
} }
if (write(w->fd, &hdr, sizeof(hdr)) != sizeof(hdr)) { if (write(f->fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
log_puts("failed to write .wav file header\n"); log_puts("failed to write .wav file header\n");
return 0; return 0;
} }
w->curpos = w->startpos; f->curpos = f->startpos;
return 1; return 1;
} }
size_t size_t
wav_read(struct wav *w, void *data, size_t count) afile_read(struct afile *f, void *data, size_t count)
{ {
off_t maxread; off_t maxread;
ssize_t n; ssize_t n;
if (w->endpos >= 0) { if (f->endpos >= 0) {
maxread = w->endpos - w->curpos; maxread = f->endpos - f->curpos;
if (maxread == 0) { if (maxread == 0) {
#ifdef DEBUG #ifdef DEBUG
if (log_level >= 3) { if (log_level >= 3) {
log_puts(w->path); log_puts(f->path);
log_puts(": end reached\n"); log_puts(": end reached\n");
} }
#endif #endif
@ -336,28 +336,28 @@ wav_read(struct wav *w, void *data, size_t count)
if (count > maxread) if (count > maxread)
count = maxread; count = maxread;
} }
n = read(w->fd, data, count); n = read(f->fd, data, count);
if (n < 0) { if (n < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": couldn't read\n"); log_puts(": couldn't read\n");
return 0; return 0;
} }
w->curpos += n; f->curpos += n;
return n; return n;
} }
size_t size_t
wav_write(struct wav *w, void *data, size_t count) afile_write(struct afile *f, void *data, size_t count)
{ {
off_t maxwrite; off_t maxwrite;
int n; int n;
if (w->maxpos >= 0) { if (f->maxpos >= 0) {
maxwrite = w->maxpos - w->curpos; maxwrite = f->maxpos - f->curpos;
if (maxwrite == 0) { if (maxwrite == 0) {
#ifdef DEBUG #ifdef DEBUG
if (log_level >= 3) { if (log_level >= 3) {
log_puts(w->path); log_puts(f->path);
log_puts(": max file size reached\n"); log_puts(": max file size reached\n");
} }
#endif #endif
@ -366,24 +366,24 @@ wav_write(struct wav *w, void *data, size_t count)
if (count > maxwrite) if (count > maxwrite)
count = maxwrite; count = maxwrite;
} }
n = write(w->fd, data, count); n = write(f->fd, data, count);
if (n < 0) { if (n < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": couldn't write\n"); log_puts(": couldn't write\n");
return 0; return 0;
} }
w->curpos += n; f->curpos += n;
if (w->endpos < w->curpos) if (f->endpos < f->curpos)
w->endpos = w->curpos; f->endpos = f->curpos;
return n; return n;
} }
int int
wav_seek(struct wav *w, off_t pos) afile_seek(struct afile *f, off_t pos)
{ {
pos += w->startpos; pos += f->startpos;
if (w->endpos >= 0 && pos > w->endpos) { if (f->endpos >= 0 && pos > f->endpos) {
log_puts(w->path); log_puts(f->path);
log_puts(": attempt to seek ouside file boundaries\n"); log_puts(": attempt to seek ouside file boundaries\n");
return 0; return 0;
} }
@ -391,113 +391,113 @@ wav_seek(struct wav *w, off_t pos)
/* /*
* seek only if needed to avoid errors with pipes & sockets * seek only if needed to avoid errors with pipes & sockets
*/ */
if (pos != w->curpos) { if (pos != f->curpos) {
if (lseek(w->fd, pos, SEEK_SET) < 0) { if (lseek(f->fd, pos, SEEK_SET) < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": couldn't seek\n"); log_puts(": couldn't seek\n");
return 0; return 0;
} }
w->curpos = pos; f->curpos = pos;
} }
return 1; return 1;
} }
void void
wav_close(struct wav *w) afile_close(struct afile *f)
{ {
if (w->flags & WAV_FWRITE) { if (f->flags & WAV_FWRITE) {
if (w->hdr == HDR_WAV) if (f->hdr == HDR_WAV)
wav_writehdr(w); afile_wav_writehdr(f);
} }
close(w->fd); close(f->fd);
} }
int int
wav_open(struct wav *w, char *path, int hdr, int flags, afile_open(struct afile *f, char *path, int hdr, int flags,
struct aparams *par, int rate, int nch) struct aparams *par, int rate, int nch)
{ {
char *ext; char *ext;
struct wavhdr dummy; struct wavhdr dummy;
w->par = *par; f->par = *par;
w->rate = rate; f->rate = rate;
w->nch = nch; f->nch = nch;
w->flags = flags; f->flags = flags;
w->hdr = hdr; f->hdr = hdr;
if (hdr == HDR_AUTO) { if (hdr == HDR_AUTO) {
w->hdr = HDR_RAW; f->hdr = HDR_RAW;
ext = strrchr(path, '.'); ext = strrchr(path, '.');
if (ext != NULL) { if (ext != NULL) {
ext++; ext++;
if (strcasecmp(ext, "wav") == 0) if (strcasecmp(ext, "afile") == 0)
w->hdr = HDR_WAV; f->hdr = HDR_WAV;
} }
} }
if (w->flags == WAV_FREAD) { if (f->flags == WAV_FREAD) {
if (strcmp(path, "-") == 0) { if (strcmp(path, "-") == 0) {
w->path = "stdin"; f->path = "stdin";
w->fd = STDIN_FILENO; f->fd = STDIN_FILENO;
} else { } else {
w->path = path; f->path = path;
w->fd = open(w->path, O_RDONLY, 0); f->fd = open(f->path, O_RDONLY, 0);
if (w->fd < 0) { if (f->fd < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": failed to open for reading\n"); log_puts(": failed to open for reading\n");
return 0; return 0;
} }
} }
if (w->hdr == HDR_WAV) { if (f->hdr == HDR_WAV) {
if (!wav_readhdr(w)) if (!afile_wav_readhdr(f))
goto bad_close; goto bad_close;
} else { } else {
w->startpos = 0; f->startpos = 0;
w->endpos = -1; /* read until EOF */ f->endpos = -1; /* read until EOF */
w->enc = ENC_PCM; f->enc = ENC_PCM;
} }
w->curpos = w->startpos; f->curpos = f->startpos;
} else if (flags == WAV_FWRITE) { } else if (flags == WAV_FWRITE) {
if (strcmp(path, "-") == 0) { if (strcmp(path, "-") == 0) {
w->path = "stdout"; f->path = "stdout";
w->fd = STDOUT_FILENO; f->fd = STDOUT_FILENO;
} else { } else {
w->path = path; f->path = path;
w->fd = open(w->path, O_WRONLY | O_TRUNC | O_CREAT, 0666); f->fd = open(f->path, O_WRONLY | O_TRUNC | O_CREAT, 0666);
if (w->fd < 0) { if (f->fd < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": failed to create file\n"); log_puts(": failed to create file\n");
return 0; return 0;
} }
} }
if (w->hdr == HDR_WAV) { if (f->hdr == HDR_WAV) {
w->par.bps = (w->par.bits + 7) >> 3; f->par.bps = (f->par.bits + 7) >> 3;
if (w->par.bits > 8) { if (f->par.bits > 8) {
w->par.le = 1; f->par.le = 1;
w->par.sig = 1; f->par.sig = 1;
} else } else
w->par.sig = 0; f->par.sig = 0;
if (w->par.bits & 7) if (f->par.bits & 7)
w->par.msb = 1; f->par.msb = 1;
w->endpos = w->startpos = sizeof(struct wavhdr); f->endpos = f->startpos = sizeof(struct wavhdr);
w->maxpos = WAV_MAXPOS; f->maxpos = WAV_MAXPOS;
memset(&dummy, 0xd0, sizeof(struct wavhdr)); memset(&dummy, 0xd0, sizeof(struct wavhdr));
if (write(w->fd, &dummy, sizeof(struct wavhdr)) < 0) { if (write(f->fd, &dummy, sizeof(struct wavhdr)) < 0) {
log_puts(w->path); log_puts(f->path);
log_puts(": failed reserve space for .wav header\n"); log_puts(": failed reserve space for .wav header\n");
goto bad_close; goto bad_close;
} }
} else { } else {
w->endpos = w->startpos = 0; f->endpos = f->startpos = 0;
w->maxpos = -1; f->maxpos = -1;
} }
w->curpos = w->startpos; f->curpos = f->startpos;
} else { } else {
#ifdef DEBUG #ifdef DEBUG
log_puts("wav_open: wrong flags\n"); log_puts("afile_open: wrong flags\n");
panic(); panic();
#endif #endif
} }
return 1; return 1;
bad_close: bad_close:
close(w->fd); close(f->fd);
return 0; return 0;
} }

12
aucat/wav.h → aucat/afile.h
View File

@ -20,7 +20,7 @@
#include <sys/types.h> #include <sys/types.h>
#include "dsp.h" #include "dsp.h"
struct wav { struct afile {
struct aparams par; /* file params */ struct aparams par; /* file params */
#define ENC_PCM 0 /* simple integers (fixed point) */ #define ENC_PCM 0 /* simple integers (fixed point) */
#define ENC_ULAW 1 /* 8-bit mu-law */ #define ENC_ULAW 1 /* 8-bit mu-law */
@ -44,10 +44,10 @@ struct wav {
char *path; /* file name (debug only) */ char *path; /* file name (debug only) */
}; };
int wav_open(struct wav *, char *, int, int, struct aparams *, int, int); int afile_open(struct afile *, char *, int, int, struct aparams *, int, int);
size_t wav_read(struct wav *, void *, size_t); size_t afile_read(struct afile *, void *, size_t);
size_t wav_write(struct wav *, void *, size_t); size_t afile_write(struct afile *, void *, size_t);
int wav_seek(struct wav *, off_t); int afile_seek(struct afile *, off_t);
void wav_close(struct wav *); void afile_close(struct afile *);
#endif /* !defined(WAV_H) */ #endif /* !defined(WAV_H) */

58
aucat/aucat.c
View File

@ -24,10 +24,10 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include "abuf.h" #include "abuf.h"
#include "afile.h"
#include "dsp.h" #include "dsp.h"
#include "sysex.h" #include "sysex.h"
#include "utils.h" #include "utils.h"
#include "wav.h"
#include "bsd-compat.h" #include "bsd-compat.h"
/* /*
@ -91,7 +91,7 @@ struct slot {
#define SLOT_RUN 2 /* playing/recording */ #define SLOT_RUN 2 /* playing/recording */
#define SLOT_STOP 3 /* draining (play only) */ #define SLOT_STOP 3 /* draining (play only) */
int pstate; /* one of above */ int pstate; /* one of above */
struct wav wav; /* file desc & friends */ struct afile afile; /* file desc & friends */
}; };
/* /*
@ -146,7 +146,7 @@ slot_log(struct slot *s)
"cfg", "ini", "run", "stp" "cfg", "ini", "run", "stp"
}; };
#endif #endif
log_puts(s->wav.path); log_puts(s->afile.path);
#ifdef DEBUG #ifdef DEBUG
if (log_level >= 3) { if (log_level >= 3) {
log_puts(",pst="); log_puts(",pst=");
@ -166,7 +166,7 @@ slot_flush(struct slot *s)
data = abuf_rgetblk(&s->buf, &count); data = abuf_rgetblk(&s->buf, &count);
if (count > todo) if (count > todo)
count = todo; count = todo;
n = wav_write(&s->wav, data, count); n = afile_write(&s->afile, data, count);
if (n == 0) { if (n == 0) {
slot_log(s); slot_log(s);
log_puts(": can't write, disabled\n"); log_puts(": can't write, disabled\n");
@ -189,7 +189,7 @@ slot_fill(struct slot *s)
data = abuf_wgetblk(&s->buf, &count); data = abuf_wgetblk(&s->buf, &count);
if (count > todo) if (count > todo)
count = todo; count = todo;
n = wav_read(&s->wav, data, count); n = afile_read(&s->afile, data, count);
if (n == 0) { if (n == 0) {
#ifdef DEBUG #ifdef DEBUG
if (log_level >= 3) { if (log_level >= 3) {
@ -212,14 +212,14 @@ slot_new(char *path, int mode, struct aparams *par, int hdr,
struct slot *s; struct slot *s;
s = xmalloc(sizeof(struct slot)); s = xmalloc(sizeof(struct slot));
if (!wav_open(&s->wav, path, hdr, if (!afile_open(&s->afile, path, hdr,
mode == SIO_PLAY ? WAV_FREAD : WAV_FWRITE, mode == SIO_PLAY ? WAV_FREAD : WAV_FWRITE,
par, rate, cmax - cmin + 1)) { par, rate, cmax - cmin + 1)) {
xfree(s); xfree(s);
return 0; return 0;
} }
s->cmin = cmin; s->cmin = cmin;
s->cmax = cmin + s->wav.nch - 1; s->cmax = cmin + s->afile.nch - 1;
s->dup = dup; s->dup = dup;
s->vol = MIDI_TO_ADATA(vol); s->vol = MIDI_TO_ADATA(vol);
s->mode = mode; s->mode = mode;
@ -233,11 +233,11 @@ slot_new(char *path, int mode, struct aparams *par, int hdr,
log_puts(":"); log_puts(":");
log_putu(s->cmax); log_putu(s->cmax);
log_puts(", "); log_puts(", ");
log_putu(s->wav.rate); log_putu(s->afile.rate);
log_puts("Hz, "); log_puts("Hz, ");
switch (s->wav.enc) { switch (s->afile.enc) {
case ENC_PCM: case ENC_PCM:
aparams_log(&s->wav.par); aparams_log(&s->afile.par);
break; break;
case ENC_ULAW: case ENC_ULAW:
log_puts("ulaw"); log_puts("ulaw");
@ -249,9 +249,9 @@ slot_new(char *path, int mode, struct aparams *par, int hdr,
log_puts("f32le"); log_puts("f32le");
break; break;
} }
if (s->mode == SIO_PLAY && s->wav.endpos >= 0) { if (s->mode == SIO_PLAY && s->afile.endpos >= 0) {
log_puts(", "); log_puts(", ");
log_puti(s->wav.endpos - s->wav.startpos); log_puti(s->afile.endpos - s->afile.startpos);
log_puts(" bytes"); log_puts(" bytes");
} }
log_puts("\n"); log_puts("\n");
@ -273,8 +273,8 @@ slot_init(struct slot *s)
panic(); panic();
} }
#endif #endif
s->bpf = s->wav.par.bps * (s->cmax - s->cmin + 1); s->bpf = s->afile.par.bps * (s->cmax - s->cmin + 1);
s->round = (dev_round * s->wav.rate + dev_rate / 2) / dev_rate; s->round = (dev_round * s->afile.rate + dev_rate / 2) / dev_rate;
bufsz = s->round * (dev_bufsz / dev_round); bufsz = s->round * (dev_bufsz / dev_round);
bufsz -= bufsz % s->round; bufsz -= bufsz % s->round;
@ -307,12 +307,12 @@ slot_init(struct slot *s)
s->cmin, s->cmax, s->cmin, s->cmax,
0, dev_pchan - 1, 0, dev_pchan - 1,
0, dev_pchan - 1); 0, dev_pchan - 1);
if (s->wav.enc != ENC_PCM || !aparams_native(&s->wav.par)) { if (s->afile.enc != ENC_PCM || !aparams_native(&s->afile.par)) {
dec_init(&s->conv, &s->wav.par, slot_nch); dec_init(&s->conv, &s->afile.par, slot_nch);
s->convbuf = s->convbuf =
xmalloc(s->round * slot_nch * sizeof(adata_t)); xmalloc(s->round * slot_nch * sizeof(adata_t));
} }
if (s->wav.rate != dev_rate) { if (s->afile.rate != dev_rate) {
resamp_init(&s->resamp, s->round, dev_round, resamp_init(&s->resamp, s->round, dev_round,
slot_nch); slot_nch);
s->resampbuf = s->resampbuf =
@ -331,14 +331,14 @@ slot_init(struct slot *s)
0, dev_rchan - 1, 0, dev_rchan - 1,
s->cmin, s->cmax, s->cmin, s->cmax,
s->cmin, s->cmax); s->cmin, s->cmax);
if (s->wav.rate != dev_rate) { if (s->afile.rate != dev_rate) {
resamp_init(&s->resamp, dev_round, s->round, resamp_init(&s->resamp, dev_round, s->round,
slot_nch); slot_nch);
s->resampbuf = s->resampbuf =
xmalloc(dev_round * slot_nch * sizeof(adata_t)); xmalloc(dev_round * slot_nch * sizeof(adata_t));
} }
if (!aparams_native(&s->wav.par)) { if (!aparams_native(&s->afile.par)) {
enc_init(&s->conv, &s->wav.par, slot_nch); enc_init(&s->conv, &s->afile.par, slot_nch);
s->convbuf = s->convbuf =
xmalloc(s->round * slot_nch * sizeof(adata_t)); xmalloc(s->round * slot_nch * sizeof(adata_t));
} }
@ -364,8 +364,8 @@ slot_start(struct slot *s, unsigned int mmc)
panic(); panic();
} }
#endif #endif
mmcpos = ((off_t)mmc * s->wav.rate / MTC_SEC) * s->bpf; mmcpos = ((off_t)mmc * s->afile.rate / MTC_SEC) * s->bpf;
if (!wav_seek(&s->wav, mmcpos)) { if (!afile_seek(&s->afile, mmcpos)) {
s->pstate = SLOT_INIT; s->pstate = SLOT_INIT;
return; return;
} }
@ -405,7 +405,7 @@ slot_del(struct slot *s)
if (s->pstate != SLOT_CFG) { if (s->pstate != SLOT_CFG) {
slot_stop(s); slot_stop(s);
wav_close(&s->wav); afile_close(&s->afile);
#ifdef DEBUG #ifdef DEBUG
if (log_level >= 3) { if (log_level >= 3) {
slot_log(s); slot_log(s);
@ -461,7 +461,7 @@ play_filt_dec(struct slot *s, void *in, void *out, int todo)
tmp = s->convbuf; tmp = s->convbuf;
if (tmp) { if (tmp) {
switch (s->wav.enc) { switch (s->afile.enc) {
case ENC_PCM: case ENC_PCM:
dec_do(&s->conv, in, tmp, todo); dec_do(&s->conv, in, tmp, todo);
break; break;
@ -595,8 +595,8 @@ dev_open(char *dev, int mode, int bufsz, char *port)
rate = pmax = rmax = 0; rate = pmax = rmax = 0;
for (s = slot_list; s != NULL; s = s->next) { for (s = slot_list; s != NULL; s = s->next) {
if (s->wav.rate > rate) if (s->afile.rate > rate)
rate = s->wav.rate; rate = s->afile.rate;
if (s->mode == SIO_PLAY) { if (s->mode == SIO_PLAY) {
if (s->cmax > pmax) if (s->cmax > pmax)
pmax = s->cmax; pmax = s->cmax;
@ -973,8 +973,8 @@ offline(void)
rate = cmax = 0; rate = cmax = 0;
for (s = slot_list; s != NULL; s = s->next) { for (s = slot_list; s != NULL; s = s->next) {
if (s->wav.rate > rate) if (s->afile.rate > rate)
rate = s->wav.rate; rate = s->afile.rate;
if (s->cmax > cmax) if (s->cmax > cmax)
cmax = s->cmax; cmax = s->cmax;
} }
@ -1196,7 +1196,7 @@ opt_hdr(char *s, int *hdr)
*hdr = HDR_RAW; *hdr = HDR_RAW;
return 1; return 1;
} }
if (strcmp("wav", s) == 0) { if (strcmp("afile", s) == 0) {
*hdr = HDR_WAV; *hdr = HDR_WAV;
return 1; return 1;
} }

6
aucat/dsp.c
View File

@ -38,7 +38,7 @@ int aparams_ctltovol[128] = {
26008, 27029, 28090, 29193, 30339, 31530, 32768 26008, 27029, 28090, 29193, 30339, 31530, 32768
}; };
short wav_ulawmap[256] = { short afile_ulawmap[256] = {
-32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956, -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
-23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764, -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
-15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412, -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
@ -73,7 +73,7 @@ short wav_ulawmap[256] = {
56, 48, 40, 32, 24, 16, 8, 0 56, 48, 40, 32, 24, 16, 8, 0
}; };
short wav_alawmap[256] = { short afile_alawmap[256] = {
-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736, -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784, -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368, -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
@ -677,7 +677,7 @@ dec_do_ulaw(struct conv *p, unsigned char *in, unsigned char *out, int todo, int
log_puts(" frames\n"); log_puts(" frames\n");
} }
#endif #endif
map = is_alaw ? wav_alawmap : wav_ulawmap; map = is_alaw ? afile_alawmap : afile_ulawmap;
idata = in; idata = in;
odata = (adata_t *)out; odata = (adata_t *)out;
for (f = todo * p->nch; f > 0; f--) for (f = todo * p->nch; f > 0; f--)