Annotation of src/usr.bin/aucat/aucat.c, Revision 1.146
1.1 kstailey 1: /*
1.146 ! ratchov 2: * Copyright (c) 2008-2014 Alexandre Ratchov <alex@caoua.org>
1.1 kstailey 3: *
1.15 ratchov 4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: */
1.145 deraadt 16:
1.146 ! ratchov 17: #include <fcntl.h>
1.55 ratchov 18: #include <errno.h>
1.146 ! ratchov 19: #include <poll.h>
1.15 ratchov 20: #include <signal.h>
1.135 ratchov 21: #include <sndio.h>
1.1 kstailey 22: #include <stdio.h>
1.4 millert 23: #include <stdlib.h>
1.8 david 24: #include <string.h>
1.1 kstailey 25: #include <unistd.h>
1.146 ! ratchov 26: #include "abuf.h"
! 27: #include "afile.h"
! 28: #include "dsp.h"
! 29: #include "sysex.h"
! 30: #include "utils.h"
! 31:
! 32: /*
! 33: * masks to extract command and channel of status byte
! 34: */
! 35: #define MIDI_CMDMASK 0xf0
! 36: #define MIDI_CHANMASK 0x0f
! 37:
! 38: /*
! 39: * MIDI status bytes of voice messages
! 40: */
! 41: #define MIDI_NOFF 0x80 /* note off */
! 42: #define MIDI_NON 0x90 /* note on */
! 43: #define MIDI_KAT 0xa0 /* key after touch */
! 44: #define MIDI_CTL 0xb0 /* controller */
! 45: #define MIDI_PC 0xc0 /* program change */
! 46: #define MIDI_CAT 0xd0 /* channel after touch */
! 47: #define MIDI_BEND 0xe0 /* pitch bend */
! 48: #define MIDI_ACK 0xfe /* active sensing message */
! 49:
! 50: /*
! 51: * MIDI controller numbers
! 52: */
! 53: #define MIDI_CTL_VOL 7
! 54:
! 55: /*
! 56: * Max coarse value
! 57: */
! 58: #define MIDI_MAXCTL 127
! 59:
! 60: /*
! 61: * MIDI status bytes for sysex
! 62: */
! 63: #define MIDI_SX_START 0xf0
! 64: #define MIDI_SX_STOP 0xf7
! 65:
! 66: /*
! 67: * audio device defaults
! 68: */
! 69: #define DEFAULT_RATE 48000
! 70: #define DEFAULT_BUFSZ_MS 200
! 71:
! 72: struct slot {
! 73: struct slot *next; /* next on the play list */
! 74: int vol; /* dynamic range */
! 75: int volctl; /* volume in the 0..127 range */
! 76: struct abuf buf; /* file i/o buffer */
! 77: int bpf; /* bytes per frame */
! 78: int cmin, cmax; /* file channel range */
! 79: struct cmap cmap; /* channel mapper state */
! 80: struct resamp resamp; /* resampler state */
! 81: struct conv conv; /* format encoder state */
! 82: int join; /* channel join factor */
! 83: int expand; /* channel expand factor */
! 84: void *resampbuf, *convbuf; /* conversion tmp buffers */
! 85: int dup; /* mono-to-stereo and alike */
! 86: int round; /* slot-side block size */
! 87: int mode; /* MODE_{PLAY,REC} */
! 88: #define SLOT_CFG 0 /* buffers not allocated yet */
! 89: #define SLOT_INIT 1 /* not trying to do anything */
! 90: #define SLOT_RUN 2 /* playing/recording */
! 91: #define SLOT_STOP 3 /* draining (play only) */
! 92: int pstate; /* one of above */
! 93: struct afile afile; /* file desc & friends */
! 94: };
! 95:
! 96: /*
! 97: * device properties
! 98: */
! 99: unsigned int dev_mode; /* bitmap of SIO_{PLAY,REC} */
! 100: unsigned int dev_bufsz; /* device buffer size */
! 101: unsigned int dev_round; /* device block size */
! 102: int dev_rate; /* device sample rate (Hz) */
! 103: unsigned int dev_pchan, dev_rchan; /* play & rec channels count */
! 104: adata_t *dev_pbuf, *dev_rbuf; /* play & rec buffers */
! 105: unsigned int dev_mmcpos; /* last MMC position */
! 106: #define DEV_STOP 0 /* stopped */
! 107: #define DEV_START 1 /* started */
! 108: unsigned int dev_pstate; /* one of above */
! 109: char *dev_name; /* device sndio(7) name */
! 110: char *dev_port; /* control port sndio(7) name */
! 111: struct sio_hdl *dev_sh; /* device handle */
! 112: struct mio_hdl *dev_mh; /* MIDI control port handle */
! 113: unsigned int dev_volctl = MIDI_MAXCTL; /* master volume */
! 114:
! 115: /*
! 116: * MIDI parser state
! 117: */
! 118: #define MIDI_MSGMAX 32 /* max size of MIDI msg */
! 119: unsigned char dev_msg[MIDI_MSGMAX]; /* parsed input message */
! 120: unsigned int dev_mst; /* input MIDI running status */
! 121: unsigned int dev_mused; /* bytes used in ``msg'' */
! 122: unsigned int dev_midx; /* current ``msg'' size */
! 123: unsigned int dev_mlen; /* expected ``msg'' length */
! 124: unsigned int dev_prime; /* blocks to write to start */
! 125:
! 126: unsigned int log_level = 1;
! 127: volatile sig_atomic_t quit_flag = 0;
! 128: struct slot *slot_list = NULL;
! 129:
! 130: /*
! 131: * length of voice and common MIDI messages (status byte included)
! 132: */
! 133: unsigned int voice_len[] = { 3, 3, 3, 3, 2, 2, 3 };
! 134: unsigned int common_len[] = { 0, 2, 3, 2, 0, 0, 1, 1 };
! 135:
! 136: char usagestr[] = "usage: aucat [-d] [-b nframes] "
! 137: "[-c min:max] [-e enc] [-f device]\n\t"
! 138: "[-j flag] [-q port] [-r rate] [-v volume]\n";
! 139:
! 140: static void
! 141: slot_log(struct slot *s)
! 142: {
! 143: #ifdef DEBUG
! 144: static char *pstates[] = {
! 145: "cfg", "ini", "run", "stp"
! 146: };
! 147: #endif
! 148: log_puts(s->afile.path);
! 149: #ifdef DEBUG
! 150: if (log_level >= 3) {
! 151: log_puts(",pst=");
! 152: log_puts(pstates[s->pstate]);
! 153: }
! 154: #endif
! 155: }
! 156:
! 157: static void
! 158: slot_flush(struct slot *s)
! 159: {
! 160: int todo, count, n;
! 161: unsigned char *data;
! 162:
! 163: todo = s->buf.used;
! 164: while (todo > 0) {
! 165: data = abuf_rgetblk(&s->buf, &count);
! 166: if (count > todo)
! 167: count = todo;
! 168: n = afile_write(&s->afile, data, count);
! 169: if (n == 0) {
! 170: slot_log(s);
! 171: log_puts(": can't write, disabled\n");
! 172: s->pstate = SLOT_INIT;
! 173: return;
! 174: }
! 175: abuf_rdiscard(&s->buf, n);
! 176: todo -= n;
! 177: }
! 178: }
! 179:
! 180: static void
! 181: slot_fill(struct slot *s)
! 182: {
! 183: int todo, count, n;
! 184: unsigned char *data;
! 185:
! 186: todo = s->buf.len;
! 187: while (todo > 0) {
! 188: data = abuf_wgetblk(&s->buf, &count);
! 189: if (count > todo)
! 190: count = todo;
! 191: n = afile_read(&s->afile, data, count);
! 192: if (n == 0) {
! 193: #ifdef DEBUG
! 194: if (log_level >= 3) {
! 195: slot_log(s);
! 196: log_puts(": eof reached, stopping\n");
! 197: }
! 198: #endif
! 199: s->pstate = SLOT_STOP;
! 200: break;
! 201: }
! 202: abuf_wcommit(&s->buf, n);
! 203: todo -= n;
! 204: }
! 205: }
! 206:
! 207: static int
! 208: slot_new(char *path, int mode, struct aparams *par, int hdr,
! 209: int cmin, int cmax, int rate, int dup, int vol)
! 210: {
! 211: struct slot *s;
! 212:
! 213: s = xmalloc(sizeof(struct slot));
! 214: if (!afile_open(&s->afile, path, hdr,
! 215: mode == SIO_PLAY ? AFILE_FREAD : AFILE_FWRITE,
! 216: par, rate, cmax - cmin + 1)) {
! 217: xfree(s);
! 218: return 0;
! 219: }
! 220: s->cmin = cmin;
! 221: s->cmax = cmin + s->afile.nch - 1;
! 222: s->dup = dup;
! 223: s->vol = MIDI_TO_ADATA(vol);
! 224: s->mode = mode;
! 225: s->pstate = SLOT_CFG;
! 226: if (log_level >= 2) {
! 227: slot_log(s);
! 228: log_puts(": ");
! 229: log_puts(s->mode == SIO_PLAY ? "play" : "rec");
! 230: log_puts(", chan ");
! 231: log_putu(s->cmin);
! 232: log_puts(":");
! 233: log_putu(s->cmax);
! 234: log_puts(", ");
! 235: log_putu(s->afile.rate);
! 236: log_puts("Hz, ");
! 237: switch (s->afile.fmt) {
! 238: case AFILE_FMT_PCM:
! 239: aparams_log(&s->afile.par);
! 240: break;
! 241: case AFILE_FMT_ULAW:
! 242: log_puts("ulaw");
! 243: break;
! 244: case AFILE_FMT_ALAW:
! 245: log_puts("alaw");
! 246: break;
! 247: case AFILE_FMT_FLOAT:
! 248: log_puts("f32le");
! 249: break;
! 250: }
! 251: if (s->mode == SIO_PLAY && s->afile.endpos >= 0) {
! 252: log_puts(", bytes ");
! 253: log_puti(s->afile.startpos);
! 254: log_puts("..");
! 255: log_puti(s->afile.endpos);
! 256: }
! 257: log_puts("\n");
! 258: }
! 259: s->next = slot_list;
! 260: slot_list = s;
! 261: return 1;
! 262: }
! 263:
! 264: static void
! 265: slot_init(struct slot *s)
! 266: {
! 267: unsigned int slot_nch, bufsz;
! 268:
! 269: #ifdef DEBUG
! 270: if (s->pstate != SLOT_CFG) {
! 271: slot_log(s);
! 272: log_puts(": slot_init: wrong state\n");
! 273: panic();
! 274: }
! 275: #endif
! 276: s->bpf = s->afile.par.bps * (s->cmax - s->cmin + 1);
! 277: s->round = (dev_round * s->afile.rate + dev_rate / 2) / dev_rate;
! 278:
! 279: bufsz = s->round * (dev_bufsz / dev_round);
! 280: bufsz -= bufsz % s->round;
! 281: if (bufsz == 0)
! 282: bufsz = s->round;
! 283: abuf_init(&s->buf, bufsz * s->bpf);
! 284: #ifdef DEBUG
! 285: if (log_level >= 3) {
! 286: slot_log(s);
! 287: log_puts(": allocated ");
! 288: log_putu(bufsz);
! 289: log_puts(" frame buffer\n");
! 290: }
! 291: #endif
! 292:
! 293: slot_nch = s->cmax - s->cmin + 1;
! 294: s->convbuf = NULL;
! 295: s->resampbuf = NULL;
! 296: s->join = 1;
! 297: s->expand = 1;
! 298: if (s->mode & SIO_PLAY) {
! 299: if (s->dup) {
! 300: if (dev_pchan > slot_nch)
! 301: s->expand = dev_pchan / slot_nch;
! 302: else if (dev_pchan < slot_nch)
! 303: s->join = slot_nch / dev_pchan;
! 304: }
! 305: cmap_init(&s->cmap,
! 306: s->cmin, s->cmax,
! 307: s->cmin, s->cmax,
! 308: 0, dev_pchan - 1,
! 309: 0, dev_pchan - 1);
! 310: if (s->afile.fmt != AFILE_FMT_PCM || !aparams_native(&s->afile.par)) {
! 311: dec_init(&s->conv, &s->afile.par, slot_nch);
! 312: s->convbuf =
! 313: xmalloc(s->round * slot_nch * sizeof(adata_t));
! 314: }
! 315: if (s->afile.rate != dev_rate) {
! 316: resamp_init(&s->resamp, s->round, dev_round,
! 317: slot_nch);
! 318: s->resampbuf =
! 319: xmalloc(dev_round * slot_nch * sizeof(adata_t));
! 320: }
! 321: }
! 322: if (s->mode & SIO_REC) {
! 323: if (s->dup) {
! 324: if (dev_rchan > slot_nch)
! 325: s->join = dev_rchan / slot_nch;
! 326: else if (dev_rchan < slot_nch)
! 327: s->expand = slot_nch / dev_rchan;
! 328: }
! 329: cmap_init(&s->cmap,
! 330: 0, dev_rchan - 1,
! 331: 0, dev_rchan - 1,
! 332: s->cmin, s->cmax,
! 333: s->cmin, s->cmax);
! 334: if (s->afile.rate != dev_rate) {
! 335: resamp_init(&s->resamp, dev_round, s->round,
! 336: slot_nch);
! 337: s->resampbuf =
! 338: xmalloc(dev_round * slot_nch * sizeof(adata_t));
! 339: }
! 340: if (!aparams_native(&s->afile.par)) {
! 341: enc_init(&s->conv, &s->afile.par, slot_nch);
! 342: s->convbuf =
! 343: xmalloc(s->round * slot_nch * sizeof(adata_t));
! 344: }
! 345: }
! 346: s->pstate = SLOT_INIT;
! 347: #ifdef DEBUG
! 348: if (log_level >= 3) {
! 349: slot_log(s);
! 350: log_puts(": chain initialized\n");
! 351: }
! 352: #endif
! 353: }
! 354:
! 355: static void
! 356: slot_start(struct slot *s, unsigned int mmc)
! 357: {
! 358: off_t mmcpos;
! 359:
! 360: #ifdef DEBUG
! 361: if (s->pstate != SLOT_INIT) {
! 362: slot_log(s);
! 363: log_puts(": slot_start: wrong state\n");
! 364: panic();
! 365: }
! 366: #endif
! 367: mmcpos = ((off_t)mmc * s->afile.rate / MTC_SEC) * s->bpf;
! 368: if (!afile_seek(&s->afile, mmcpos)) {
! 369: s->pstate = SLOT_INIT;
! 370: return;
! 371: }
! 372: s->pstate = SLOT_RUN;
! 373: if (s->mode & SIO_PLAY)
! 374: slot_fill(s);
! 375: #ifdef DEBUG
! 376: if (log_level >= 2) {
! 377: slot_log(s);
! 378: log_puts(": started\n");
! 379: }
! 380: #endif
! 381: }
1.1 kstailey 382:
1.146 ! ratchov 383: static void
! 384: slot_stop(struct slot *s)
! 385: {
! 386: if (s->pstate == SLOT_INIT)
! 387: return;
! 388: if (s->mode & SIO_REC)
! 389: slot_flush(s);
! 390: if (s->mode & SIO_PLAY)
! 391: s->buf.used = s->buf.start = 0;
! 392: s->pstate = SLOT_INIT;
1.78 ratchov 393: #ifdef DEBUG
1.146 ! ratchov 394: if (log_level >= 2) {
! 395: slot_log(s);
! 396: log_puts(": stopped\n");
! 397: }
1.78 ratchov 398: #endif
1.146 ! ratchov 399: }
1.11 jaredy 400:
1.146 ! ratchov 401: static void
! 402: slot_del(struct slot *s)
! 403: {
! 404: struct slot **ps;
1.61 ratchov 405:
1.146 ! ratchov 406: if (s->pstate != SLOT_CFG) {
! 407: slot_stop(s);
! 408: afile_close(&s->afile);
! 409: #ifdef DEBUG
! 410: if (log_level >= 3) {
! 411: slot_log(s);
! 412: log_puts(": closed\n");
! 413: }
1.108 ratchov 414: #endif
1.146 ! ratchov 415: abuf_done(&s->buf);
! 416: if (s->resampbuf)
! 417: xfree(s->resampbuf);
! 418: if (s->convbuf)
! 419: xfree(s->convbuf);
! 420: }
! 421: for (ps = &slot_list; *ps != s; ps = &(*ps)->next)
! 422: ; /* nothing */
! 423: *ps = s->next;
! 424: xfree(s);
! 425: }
! 426:
! 427: static int
! 428: play_filt_resamp(struct slot *s, void *res_in, void *out, int todo)
! 429: {
! 430: int i, offs, vol, nch;
! 431: void *in;
! 432:
! 433: if (s->resampbuf) {
! 434: todo = resamp_do(&s->resamp,
! 435: res_in, s->resampbuf, todo);
! 436: in = s->resampbuf;
! 437: } else
! 438: in = res_in;
! 439:
! 440: nch = s->cmap.nch;
! 441: vol = s->vol / s->join; /* XXX */
! 442: cmap_add(&s->cmap, in, out, vol, todo);
! 443:
! 444: offs = 0;
! 445: for (i = s->join - 1; i > 0; i--) {
! 446: offs += nch;
! 447: cmap_add(&s->cmap, (adata_t *)in + offs, out, vol, todo);
! 448: }
! 449: offs = 0;
! 450: for (i = s->expand - 1; i > 0; i--) {
! 451: offs += nch;
! 452: cmap_add(&s->cmap, in, (adata_t *)out + offs, vol, todo);
! 453: }
! 454: return todo;
! 455: }
! 456:
! 457: static int
! 458: play_filt_dec(struct slot *s, void *in, void *out, int todo)
! 459: {
! 460: void *tmp;
! 461:
! 462: tmp = s->convbuf;
! 463: if (tmp) {
! 464: switch (s->afile.fmt) {
! 465: case AFILE_FMT_PCM:
! 466: dec_do(&s->conv, in, tmp, todo);
! 467: break;
! 468: case AFILE_FMT_ULAW:
! 469: dec_do_ulaw(&s->conv, in, tmp, todo, 0);
! 470: break;
! 471: case AFILE_FMT_ALAW:
! 472: dec_do_ulaw(&s->conv, in, tmp, todo, 1);
! 473: break;
! 474: case AFILE_FMT_FLOAT:
! 475: dec_do_float(&s->conv, in, tmp, todo);
! 476: break;
! 477: }
! 478: }
! 479: return play_filt_resamp(s, tmp ? tmp : in, out, todo);
! 480: }
1.108 ratchov 481:
1.120 ratchov 482: /*
1.146 ! ratchov 483: * Mix as many as possible frames (but not more than a block) from the
! 484: * slot buffer to the given location. Return the number of frames mixed
! 485: * in the output buffer
1.120 ratchov 486: */
1.146 ! ratchov 487: static int
! 488: slot_mix_badd(struct slot *s, adata_t *odata)
! 489: {
! 490: adata_t *idata;
! 491: int icount, todo, done;
! 492:
! 493: idata = (adata_t *)abuf_rgetblk(&s->buf, &icount);
! 494: todo = icount / s->bpf;
! 495: if (todo > s->round)
! 496: todo = s->round;
! 497: #ifdef DEBUG
! 498: if (todo == 0) {
! 499: log_puts("slot_mix_badd: not enough data\n");
! 500: panic();
! 501: }
1.133 ratchov 502: #endif
1.146 ! ratchov 503: done = play_filt_dec(s, idata, odata, todo);
! 504: abuf_rdiscard(&s->buf, todo * s->bpf);
! 505: return done;
! 506: }
! 507:
! 508: static int
! 509: rec_filt_resamp(struct slot *s, void *in, void *res_out, int todo)
! 510: {
! 511: int i, vol, offs, nch;
! 512: void *out = res_out;
! 513:
! 514: out = (s->resampbuf) ? s->resampbuf : res_out;
! 515:
! 516: nch = s->cmap.nch;
! 517: vol = ADATA_UNIT / s->join;
! 518: cmap_copy(&s->cmap, in, out, vol, todo);
! 519:
! 520: offs = 0;
! 521: for (i = s->join - 1; i > 0; i--) {
! 522: offs += nch;
! 523: cmap_add(&s->cmap, (adata_t *)in + offs, out, vol, todo);
! 524: }
! 525: offs = 0;
! 526: for (i = s->expand - 1; i > 0; i--) {
! 527: offs += nch;
! 528: cmap_copy(&s->cmap, in, (adata_t *)out + offs, vol, todo);
! 529: }
! 530: if (s->resampbuf) {
! 531: todo = resamp_do(&s->resamp,
! 532: s->resampbuf, res_out, todo);
! 533: }
! 534: return todo;
! 535: }
! 536:
! 537: static int
! 538: rec_filt_enc(struct slot *s, void *in, void *out, int todo)
! 539: {
! 540: void *tmp;
! 541:
! 542: tmp = s->convbuf;
! 543: todo = rec_filt_resamp(s, in, tmp ? tmp : out, todo);
! 544: if (tmp)
! 545: enc_do(&s->conv, tmp, out, todo);
! 546: return todo;
! 547: }
1.133 ratchov 548:
549: /*
1.146 ! ratchov 550: * Copy "todo" frames from the given buffer to the slot buffer,
! 551: * but not more than a block.
1.133 ratchov 552: */
1.146 ! ratchov 553: static void
! 554: slot_sub_bcopy(struct slot *s, adata_t *idata, int todo)
! 555: {
! 556: adata_t *odata;
! 557: int ocount;
! 558:
! 559: odata = (adata_t *)abuf_wgetblk(&s->buf, &ocount);
! 560: #ifdef DEBUG
! 561: if (ocount < s->round * s->bpf) {
! 562: log_puts("slot_sub_bcopy: not enough space\n");
! 563: panic();
! 564: }
1.120 ratchov 565: #endif
1.146 ! ratchov 566: ocount = rec_filt_enc(s, idata, odata, todo);
! 567: abuf_wcommit(&s->buf, ocount * s->bpf);
! 568: }
! 569:
! 570: static int
! 571: dev_open(char *dev, int mode, int bufsz, char *port)
! 572: {
! 573: int rate, pmax, rmax;
! 574: struct sio_par par;
! 575: struct slot *s;
! 576:
! 577: if (port) {
! 578: dev_port = port;
! 579: dev_mh = mio_open(dev_port, MIO_IN, 0);
! 580: if (dev_mh == NULL) {
! 581: log_puts(port);
! 582: log_puts(": couldn't open midi port\n");
! 583: return 0;
! 584: }
! 585: } else
! 586: dev_mh = NULL;
! 587:
! 588: dev_name = dev;
! 589: dev_sh = sio_open(dev, mode, 0);
! 590: if (dev_sh == NULL) {
! 591: log_puts(dev_name);
! 592: log_puts(": couldn't open audio device\n");
! 593: return 0;
! 594: }
! 595:
! 596: rate = pmax = rmax = 0;
! 597: for (s = slot_list; s != NULL; s = s->next) {
! 598: if (s->afile.rate > rate)
! 599: rate = s->afile.rate;
! 600: if (s->mode == SIO_PLAY) {
! 601: if (s->cmax > pmax)
! 602: pmax = s->cmax;
! 603: }
! 604: if (s->mode == SIO_REC) {
! 605: if (s->cmax > rmax)
! 606: rmax = s->cmax;
! 607: }
! 608: }
! 609: sio_initpar(&par);
! 610: par.bits = ADATA_BITS;
! 611: par.bps = sizeof(adata_t);
! 612: par.msb = 0;
! 613: par.le = SIO_LE_NATIVE;
! 614: if (mode & SIO_PLAY)
! 615: par.pchan = pmax + 1;
! 616: if (mode & SIO_REC)
! 617: par.rchan = rmax + 1;
! 618: par.appbufsz = bufsz > 0 ? bufsz : rate * DEFAULT_BUFSZ_MS / 1000;
! 619: if (!sio_setpar(dev_sh, &par) || !sio_getpar(dev_sh, &par)) {
! 620: log_puts(dev_name);
! 621: log_puts(": couldn't set audio params\n");
! 622: return 0;
! 623: }
! 624: if (par.bits != ADATA_BITS ||
! 625: par.bps != sizeof(adata_t) ||
! 626: par.le != SIO_LE_NATIVE ||
! 627: (par.bps != SIO_BPS(par.bits) && par.msb)) {
! 628: log_puts(dev_name);
! 629: log_puts(": unsupported audio params\n");
! 630: return 0;
! 631: }
! 632: dev_mode = mode;
! 633: dev_rate = par.rate;
! 634: dev_bufsz = par.bufsz;
! 635: dev_round = par.round;
! 636: if (mode & SIO_PLAY) {
! 637: dev_pchan = par.pchan;
! 638: dev_pbuf = xmalloc(sizeof(adata_t) * dev_pchan * dev_round);
! 639: }
! 640: if (mode & SIO_REC) {
! 641: dev_rchan = par.rchan;
! 642: dev_rbuf = xmalloc(sizeof(adata_t) * dev_rchan * dev_round);
! 643: }
! 644: dev_mmcpos = 0;
! 645: dev_pstate = DEV_STOP;
! 646: if (log_level >= 2) {
! 647: log_puts(dev_name);
! 648: log_puts(": ");
! 649: log_putu(dev_rate);
! 650: log_puts("Hz");
! 651: if (dev_mode & SIO_PLAY) {
! 652: log_puts(", play 0:");
! 653: log_puti(dev_pchan - 1);
! 654: }
! 655: if (dev_mode & SIO_REC) {
! 656: log_puts(", rec 0:");
! 657: log_puti(dev_rchan - 1);
! 658: }
! 659: log_puts(", ");
! 660: log_putu(dev_bufsz / dev_round);
! 661: log_puts(" blocks of ");
! 662: log_putu(dev_round);
! 663: log_puts(" frames\n");
! 664: }
! 665: return 1;
! 666: }
1.120 ratchov 667:
1.146 ! ratchov 668: static void
! 669: dev_close(void)
! 670: {
! 671: sio_close(dev_sh);
! 672: if (dev_mh)
! 673: mio_close(dev_mh);
! 674: if (dev_mode & SIO_PLAY)
! 675: xfree(dev_pbuf);
! 676: if (dev_mode & SIO_REC)
! 677: xfree(dev_rbuf);
! 678: }
! 679:
! 680: static void
! 681: dev_master(int val)
! 682: {
! 683: struct slot *s;
! 684: int mastervol, slotvol;
1.143 ratchov 685:
1.146 ! ratchov 686: mastervol = MIDI_TO_ADATA(dev_volctl);
! 687: for (s = slot_list; s != NULL; s = s->next) {
! 688: slotvol = MIDI_TO_ADATA(val);
! 689: s->vol = ADATA_MUL(mastervol, slotvol);
! 690: }
1.78 ratchov 691: #ifdef DEBUG
1.146 ! ratchov 692: if (log_level >= 3) {
! 693: log_puts("master volume set to ");
! 694: log_putu(val);
! 695: log_puts("\n");
! 696: }
1.78 ratchov 697: #endif
1.146 ! ratchov 698: }
1.7 deraadt 699:
1.146 ! ratchov 700: static void
! 701: dev_slotvol(int midich, int val)
! 702: {
! 703: struct slot *s;
! 704: int mastervol, slotvol;
! 705:
! 706: for (s = slot_list; s != NULL; s = s->next) {
! 707: if (midich == 0) {
! 708: mastervol = MIDI_TO_ADATA(dev_volctl);
! 709: slotvol = MIDI_TO_ADATA(val);
! 710: s->vol = ADATA_MUL(mastervol, slotvol);
! 711: #ifdef DEBUG
! 712: if (log_level >= 3) {
! 713: slot_log(s);
! 714: log_puts(": volume set to ");
! 715: log_putu(val);
! 716: log_puts("\n");
! 717: }
! 718: #endif
! 719: break;
! 720: }
! 721: }
! 722: }
1.129 ratchov 723:
1.28 ratchov 724: /*
1.146 ! ratchov 725: * start all slots simultaneously
1.28 ratchov 726: */
1.146 ! ratchov 727: static void
! 728: dev_mmcstart(void)
1.28 ratchov 729: {
1.146 ! ratchov 730: struct slot *s;
! 731:
! 732: if (dev_pstate == DEV_STOP) {
! 733: dev_pstate = DEV_START;
! 734: for (s = slot_list; s != NULL; s = s->next)
! 735: slot_start(s, dev_mmcpos);
! 736: dev_prime = (dev_mode & SIO_PLAY) ? dev_bufsz / dev_round : 0;
! 737: sio_start(dev_sh);
! 738: if (log_level >= 2)
! 739: log_puts("started\n");
! 740: } else {
! 741: #ifdef DEBUG
! 742: if (log_level >= 3)
! 743: log_puts("ignoring mmc start\n");
! 744: #endif
! 745: }
1.28 ratchov 746: }
1.22 ratchov 747:
1.146 ! ratchov 748: /*
! 749: * stop all slots simultaneously
! 750: */
! 751: static void
! 752: dev_mmcstop(void)
! 753: {
! 754: struct slot *s;
! 755:
! 756: if (dev_pstate == DEV_START) {
! 757: dev_pstate = DEV_STOP;
! 758: for (s = slot_list; s != NULL; s = s->next)
! 759: slot_stop(s);
! 760: sio_stop(dev_sh);
! 761: if (log_level >= 2)
! 762: log_puts("stopped\n");
! 763: } else {
1.78 ratchov 764: #ifdef DEBUG
1.146 ! ratchov 765: if (log_level >= 3)
! 766: log_puts("ignored mmc stop\n");
! 767: #endif
! 768: }
! 769: }
! 770:
1.78 ratchov 771: /*
1.146 ! ratchov 772: * relocate all slots simultaneously
1.78 ratchov 773: */
1.146 ! ratchov 774: static void
! 775: dev_mmcloc(unsigned int mmc)
1.78 ratchov 776: {
1.146 ! ratchov 777: if (dev_mmcpos == mmc)
! 778: return;
! 779: dev_mmcpos = mmc;
! 780: if (log_level >= 2) {
! 781: log_puts("relocated to ");
! 782: log_putu((dev_mmcpos / (MTC_SEC * 3600)) % 24);
! 783: log_puts(":");
! 784: log_putu((dev_mmcpos / (MTC_SEC * 60)) % 60);
! 785: log_puts(":");
! 786: log_putu((dev_mmcpos / (MTC_SEC)) % 60);
! 787: log_puts(".");
! 788: log_putu((dev_mmcpos / (MTC_SEC / 100)) % 100);
! 789: log_puts("\n");
! 790: }
! 791: if (dev_pstate == DEV_START) {
! 792: dev_mmcstop();
! 793: dev_mmcstart();
! 794: }
! 795: }
! 796:
! 797: static void
! 798: dev_imsg(unsigned char *msg, unsigned int len)
! 799: {
! 800: struct sysex *x;
! 801: unsigned int fps, chan;
! 802:
! 803: if ((msg[0] & MIDI_CMDMASK) == MIDI_CTL && msg[1] == MIDI_CTL_VOL) {
! 804: chan = msg[0] & MIDI_CHANMASK;
! 805: dev_slotvol(chan, msg[2]);
! 806: return;
! 807: }
! 808: x = (struct sysex *)msg;
! 809: if (x->start != SYSEX_START)
! 810: return;
! 811: if (len < SYSEX_SIZE(empty))
! 812: return;
! 813: if (x->type != SYSEX_TYPE_RT)
! 814: return;
! 815: if (x->id0 == SYSEX_CONTROL && x->id1 == SYSEX_MASTER) {
! 816: if (len == SYSEX_SIZE(master))
! 817: dev_master(x->u.master.coarse);
! 818: return;
! 819: }
! 820: if (x->id0 != SYSEX_MMC)
! 821: return;
! 822: switch (x->id1) {
! 823: case SYSEX_MMC_STOP:
! 824: if (len != SYSEX_SIZE(stop))
! 825: return;
! 826: dev_mmcstop();
! 827: break;
! 828: case SYSEX_MMC_START:
! 829: if (len != SYSEX_SIZE(start))
! 830: return;
! 831: dev_mmcstart();
! 832: break;
! 833: case SYSEX_MMC_LOC:
! 834: if (len != SYSEX_SIZE(loc) ||
! 835: x->u.loc.len != SYSEX_MMC_LOC_LEN ||
! 836: x->u.loc.cmd != SYSEX_MMC_LOC_CMD)
! 837: return;
! 838: switch (x->u.loc.hr >> 5) {
! 839: case MTC_FPS_24:
! 840: fps = 24;
! 841: break;
! 842: case MTC_FPS_25:
! 843: fps = 25;
! 844: break;
! 845: case MTC_FPS_30:
! 846: fps = 30;
! 847: break;
! 848: default:
! 849: dev_mmcstop();
! 850: return;
! 851: }
! 852: dev_mmcloc((x->u.loc.hr & 0x1f) * 3600 * MTC_SEC +
! 853: x->u.loc.min * 60 * MTC_SEC +
! 854: x->u.loc.sec * MTC_SEC +
! 855: x->u.loc.fr * (MTC_SEC / fps) +
! 856: x->u.loc.cent * (MTC_SEC / 100 / fps));
! 857: break;
! 858: }
1.78 ratchov 859: }
860:
861: /*
1.146 ! ratchov 862: * parse then given data chunk, and calling imsg() for each message
1.78 ratchov 863: */
1.146 ! ratchov 864: static void
! 865: midi_in(unsigned char *idata, int icount)
1.78 ratchov 866: {
1.146 ! ratchov 867: int i;
! 868: unsigned char c;
! 869:
! 870: for (i = 0; i < icount; i++) {
! 871: c = *idata++;
! 872: if (c >= 0xf8) {
! 873: /* we don't use reat-time events */
! 874: } else if (c == SYSEX_END) {
! 875: if (dev_mst == SYSEX_START) {
! 876: dev_msg[dev_midx++] = c;
! 877: dev_imsg(dev_msg, dev_midx);
! 878: }
! 879: dev_mst = 0;
! 880: dev_midx = 0;
! 881: } else if (c >= 0xf0) {
! 882: dev_msg[0] = c;
! 883: dev_mlen = common_len[c & 7];
! 884: dev_mst = c;
! 885: dev_midx = 1;
! 886: } else if (c >= 0x80) {
! 887: dev_msg[0] = c;
! 888: dev_mlen = voice_len[(c >> 4) & 7];
! 889: dev_mst = c;
! 890: dev_midx = 1;
! 891: } else if (dev_mst) {
! 892: if (dev_midx == 0 && dev_mst != SYSEX_START)
! 893: dev_msg[dev_midx++] = dev_mst;
! 894: dev_msg[dev_midx++] = c;
! 895: if (dev_midx == dev_mlen) {
! 896: dev_imsg(dev_msg, dev_midx);
! 897: if (dev_mst >= 0xf0)
! 898: dev_mst = 0;
! 899: dev_midx = 0;
! 900: } else if (dev_midx == MIDI_MSGMAX) {
! 901: /* sysex too long */
! 902: dev_mst = 0;
! 903: }
! 904: }
! 905: }
1.78 ratchov 906: }
1.15 ratchov 907:
1.146 ! ratchov 908: static int
! 909: slot_list_mix(unsigned int round, unsigned int pchan, adata_t *pbuf)
1.15 ratchov 910: {
1.146 ! ratchov 911: unsigned int done, n;
! 912: struct slot *s;
1.13 uwe 913:
1.146 ! ratchov 914: memset(pbuf, 0, pchan * round * sizeof(adata_t));
! 915: done = 0;
! 916: for (s = slot_list; s != NULL; s = s->next) {
! 917: if (s->pstate == SLOT_INIT || !(s->mode & SIO_PLAY))
! 918: continue;
! 919: if (s->pstate == SLOT_STOP && s->buf.used < s->bpf) {
! 920: s->pstate = SLOT_INIT;
! 921: #ifdef DEBUG
! 922: if (log_level >= 3) {
! 923: slot_log(s);
! 924: log_puts(": drained, done\n");
! 925: }
! 926: #endif
! 927: continue;
! 928: }
! 929: n = slot_mix_badd(s, dev_pbuf);
! 930: if (n > done)
! 931: done = n;
! 932: }
! 933: return done;
1.15 ratchov 934: }
1.13 uwe 935:
1.146 ! ratchov 936: static int
! 937: slot_list_copy(unsigned int count, unsigned int rchan, adata_t *rbuf)
1.15 ratchov 938: {
1.146 ! ratchov 939: unsigned int done;
! 940: struct slot *s;
1.28 ratchov 941:
1.146 ! ratchov 942: done = 0;
! 943: for (s = slot_list; s != NULL; s = s->next) {
! 944: if (s->pstate == SLOT_INIT || !(s->mode & SIO_REC))
! 945: continue;
! 946: slot_sub_bcopy(s, rbuf, count);
! 947: done = count;
! 948: }
! 949: return done;
1.15 ratchov 950: }
1.4 millert 951:
1.146 ! ratchov 952: static void
! 953: slot_list_iodo(void)
1.15 ratchov 954: {
1.146 ! ratchov 955: struct slot *s;
! 956:
! 957: for (s = slot_list; s != NULL; s = s->next) {
! 958: if (s->pstate != SLOT_RUN)
! 959: continue;
! 960: if ((s->mode & SIO_PLAY) && (s->buf.used == 0))
! 961: slot_fill(s);
! 962: if ((s->mode & SIO_REC) && (s->buf.used == s->buf.len))
! 963: slot_flush(s);
! 964: }
1.1 kstailey 965: }
966:
1.146 ! ratchov 967: static int
! 968: offline(void)
1.74 ratchov 969: {
1.146 ! ratchov 970: unsigned int todo;
! 971: int rate, cmax;
! 972: struct slot *s;
! 973:
! 974: rate = cmax = 0;
! 975: for (s = slot_list; s != NULL; s = s->next) {
! 976: if (s->afile.rate > rate)
! 977: rate = s->afile.rate;
! 978: if (s->cmax > cmax)
! 979: cmax = s->cmax;
! 980: }
! 981: dev_sh = NULL;
! 982: dev_name = "offline";
! 983: dev_mode = SIO_PLAY | SIO_REC;
! 984: dev_rate = rate;
! 985: dev_bufsz = rate;
! 986: dev_round = rate;
! 987: dev_pchan = dev_rchan = cmax + 1;
! 988: dev_pbuf = dev_rbuf = xmalloc(sizeof(adata_t) * dev_pchan * dev_round);
! 989: dev_pstate = DEV_STOP;
! 990: dev_mmcpos = 0;
! 991: for (s = slot_list; s != NULL; s = s->next)
! 992: slot_init(s);
! 993: for (s = slot_list; s != NULL; s = s->next)
! 994: slot_start(s, 0);
! 995: for (;;) {
! 996: todo = slot_list_mix(dev_round, dev_pchan, dev_pbuf);
! 997: if (todo == 0)
! 998: break;
! 999: slot_list_copy(todo, dev_pchan, dev_pbuf);
! 1000: slot_list_iodo();
! 1001: }
! 1002: xfree(dev_pbuf);
! 1003: while (slot_list)
! 1004: slot_del(slot_list);
! 1005: return 1;
1.74 ratchov 1006: }
1007:
1.146 ! ratchov 1008: static int
! 1009: playrec_cycle(void)
1.84 ratchov 1010: {
1.146 ! ratchov 1011: unsigned int n, todo;
! 1012: unsigned char *p;
! 1013: int pcnt, rcnt;
! 1014:
! 1015: #ifdef DEBUG
! 1016: if (log_level >= 4) {
! 1017: log_puts(dev_name);
! 1018: log_puts(": cycle, prime = ");
! 1019: log_putu(dev_prime);
! 1020: log_puts("\n");
! 1021: }
! 1022: #endif
! 1023: pcnt = rcnt = 0;
! 1024: if (dev_mode & SIO_REC) {
! 1025: if (dev_prime > 0)
! 1026: dev_prime--;
! 1027: else {
! 1028: todo = dev_round * dev_rchan * sizeof(adata_t);
! 1029: p = (unsigned char *)dev_rbuf;
! 1030: while (todo > 0) {
! 1031: n = sio_read(dev_sh, p, todo);
! 1032: if (n == 0) {
! 1033: log_puts(dev_name);
! 1034: log_puts(": failed to read from device\n");
! 1035: return 0;
! 1036: }
! 1037: p += n;
! 1038: todo -= n;
! 1039: }
! 1040: rcnt = slot_list_copy(dev_round, dev_rchan, dev_rbuf);
! 1041: }
! 1042: }
! 1043: if (dev_mode & SIO_PLAY) {
! 1044: pcnt = slot_list_mix(dev_round, dev_pchan, dev_pbuf);
! 1045: todo = sizeof(adata_t) * dev_pchan * dev_round;
! 1046: n = sio_write(dev_sh, dev_pbuf, todo);
! 1047: if (n == 0) {
! 1048: log_puts(dev_name);
! 1049: log_puts(": failed to write to device\n");
! 1050: return 0;
! 1051: }
! 1052: }
! 1053: slot_list_iodo();
! 1054: return pcnt > 0 || rcnt > 0;
1.84 ratchov 1055: }
1056:
1.146 ! ratchov 1057: static void
! 1058: sigint(int s)
1.22 ratchov 1059: {
1.146 ! ratchov 1060: if (quit_flag)
! 1061: _exit(1);
! 1062: quit_flag = 1;
1.22 ratchov 1063: }
1064:
1.146 ! ratchov 1065: static int
! 1066: playrec(char *dev, int mode, int bufsz, char *port)
1.61 ratchov 1067: {
1.146 ! ratchov 1068: #define MIDIBUFSZ 0x100
! 1069: unsigned char mbuf[MIDIBUFSZ];
1.61 ratchov 1070: struct sigaction sa;
1.146 ! ratchov 1071: struct pollfd *pfds;
! 1072: struct slot *s;
! 1073: int n, ns, nm, ev;
! 1074:
! 1075: if (!dev_open(dev, mode, bufsz, port))
! 1076: return 0;
! 1077: n = sio_nfds(dev_sh);
! 1078: if (dev_mh)
! 1079: n += mio_nfds(dev_mh);
! 1080: pfds = xmalloc(n * sizeof(struct pollfd));
! 1081: for (s = slot_list; s != NULL; s = s->next)
! 1082: slot_init(s);
! 1083: if (dev_mh == NULL)
! 1084: dev_mmcstart();
! 1085: else {
! 1086: if (log_level >= 2)
! 1087: log_puts("ready, waiting for mmc messages\n");
! 1088: }
1.61 ratchov 1089:
1090: quit_flag = 0;
1091: sigfillset(&sa.sa_mask);
1092: sa.sa_flags = SA_RESTART;
1093: sa.sa_handler = sigint;
1.146 ! ratchov 1094: sigaction(SIGINT, &sa, NULL);
! 1095: sigaction(SIGTERM, &sa, NULL);
! 1096: sigaction(SIGHUP, &sa, NULL);
! 1097: while (!quit_flag) {
! 1098: if (dev_pstate == DEV_START) {
! 1099: ev = 0;
! 1100: if (mode & SIO_PLAY)
! 1101: ev |= POLLOUT;
! 1102: if (mode & SIO_REC)
! 1103: ev |= POLLIN;
! 1104: ns = sio_pollfd(dev_sh, pfds, ev);
! 1105: } else
! 1106: ns = 0;
! 1107: if (dev_mh)
! 1108: nm = mio_pollfd(dev_mh, pfds + ns, POLLIN);
! 1109: else
! 1110: nm = 0;
! 1111: if (poll(pfds, ns + nm, -1) < 0) {
! 1112: if (errno == EINTR)
! 1113: continue;
! 1114: log_puts("poll failed\n");
! 1115: panic();
! 1116: }
! 1117: if (dev_pstate == DEV_START) {
! 1118: ev = sio_revents(dev_sh, pfds);
! 1119: if (ev & POLLHUP) {
! 1120: log_puts(dev);
! 1121: log_puts(": audio device gone, stopping\n");
! 1122: break;
! 1123: }
! 1124: if (ev & (POLLIN | POLLOUT)) {
! 1125: if (!playrec_cycle() && dev_mh == NULL)
! 1126: break;
! 1127: }
! 1128: }
! 1129: if (dev_mh) {
! 1130: ev = mio_revents(dev_mh, pfds + ns);
! 1131: if (ev & POLLHUP) {
! 1132: log_puts(dev_port);
! 1133: log_puts(": midi port gone, stopping\n");
! 1134: break;
! 1135: }
! 1136: if (ev & POLLIN) {
! 1137: n = mio_read(dev_mh, mbuf, MIDIBUFSZ);
! 1138: midi_in(mbuf, n);
! 1139: }
! 1140: }
! 1141: }
! 1142: sigfillset(&sa.sa_mask);
! 1143: sa.sa_flags = SA_RESTART;
! 1144: sa.sa_handler = SIG_DFL;
! 1145: sigaction(SIGINT, &sa, NULL);
! 1146: sigaction(SIGTERM, &sa, NULL);
! 1147: sigaction(SIGHUP, &sa, NULL);
! 1148:
! 1149: if (dev_pstate == DEV_START)
! 1150: dev_mmcstop();
! 1151: xfree(pfds);
! 1152: dev_close();
! 1153: while (slot_list)
! 1154: slot_del(slot_list);
! 1155: return 1;
! 1156: }
! 1157:
! 1158: static int
! 1159: opt_onoff(char *s, int *flag)
! 1160: {
! 1161: if (strcmp("off", s) == 0) {
! 1162: *flag = 0;
! 1163: return 1;
! 1164: }
! 1165: if (strcmp("on", s) == 0) {
! 1166: *flag = 1;
! 1167: return 1;
! 1168: }
! 1169: log_puts(s);
! 1170: log_puts(": on/off expected\n");
! 1171: return 0;
! 1172: }
! 1173:
! 1174: static int
! 1175: opt_enc(char *s, struct aparams *par)
! 1176: {
! 1177: int len;
! 1178:
! 1179: len = aparams_strtoenc(par, s);
! 1180: if (len == 0 || s[len] != '\0') {
! 1181: log_puts(s);
! 1182: log_puts(": bad encoding\n");
! 1183: return 0;
! 1184: }
! 1185: return 1;
! 1186: }
! 1187:
! 1188: static int
! 1189: opt_hdr(char *s, int *hdr)
! 1190: {
! 1191: if (strcmp("auto", s) == 0) {
! 1192: *hdr = AFILE_HDR_AUTO;
! 1193: return 1;
! 1194: }
! 1195: if (strcmp("raw", s) == 0) {
! 1196: *hdr = AFILE_HDR_RAW;
! 1197: return 1;
! 1198: }
! 1199: if (strcmp("wav", s) == 0) {
! 1200: *hdr = AFILE_HDR_WAV;
! 1201: return 1;
! 1202: }
! 1203: if (strcmp("aiff", s) == 0) {
! 1204: *hdr = AFILE_HDR_AIFF;
! 1205: return 1;
! 1206: }
! 1207: if (strcmp("au", s) == 0) {
! 1208: *hdr = AFILE_HDR_AU;
! 1209: return 1;
! 1210: }
! 1211: log_puts(s);
! 1212: log_puts(": bad header type\n");
! 1213: return 0;
! 1214: }
! 1215:
! 1216: static int
! 1217: opt_ch(char *s, int *rcmin, int *rcmax)
! 1218: {
! 1219: char *next, *end;
! 1220: long cmin, cmax;
! 1221:
! 1222: errno = 0;
! 1223: cmin = strtol(s, &next, 10);
! 1224: if (next == s || *next != ':')
! 1225: goto failed;
! 1226: cmax = strtol(++next, &end, 10);
! 1227: if (end == next || *end != '\0')
! 1228: goto failed;
! 1229: if (cmin < 0 || cmax < cmin || cmax >= NCHAN_MAX)
! 1230: goto failed;
! 1231: *rcmin = cmin;
! 1232: *rcmax = cmax;
! 1233: return 1;
! 1234: failed:
! 1235: log_puts(s);
! 1236: log_puts(": channel range expected\n");
! 1237: return 0;
1.61 ratchov 1238: }
1239:
1.146 ! ratchov 1240: static int
! 1241: opt_num(char *s, int min, int max, int *num)
1.61 ratchov 1242: {
1.146 ! ratchov 1243: const char *errstr;
1.61 ratchov 1244:
1.146 ! ratchov 1245: *num = strtonum(s, min, max, &errstr);
! 1246: if (errstr) {
! 1247: log_puts(s);
! 1248: log_puts(": expected integer between ");
! 1249: log_puti(min);
! 1250: log_puts(" and ");
! 1251: log_puti(max);
! 1252: log_puts("\n");
! 1253: return 0;
! 1254: }
! 1255: return 1;
1.120 ratchov 1256: }
1257:
1.1 kstailey 1258: int
1.120 ratchov 1259: main(int argc, char **argv)
1.1 kstailey 1260: {
1.146 ! ratchov 1261: int dup, cmin, cmax, rate, vol, bufsz, hdr, mode;
! 1262: char *port, *dev;
! 1263: struct aparams par;
! 1264: int n_flag, c;
! 1265:
! 1266: vol = 127;
! 1267: dup = 0;
1.120 ratchov 1268: bufsz = 0;
1.146 ! ratchov 1269: rate = DEFAULT_RATE;
! 1270: cmin = 0;
! 1271: cmax = 1;
! 1272: aparams_init(&par);
! 1273: hdr = AFILE_HDR_AUTO;
! 1274: n_flag = 0;
! 1275: port = NULL;
! 1276: dev = NULL;
! 1277: mode = 0;
! 1278:
! 1279: while ((c = getopt(argc, argv, "b:c:de:f:h:i:j:no:q:r:t:v:")) != -1) {
1.15 ratchov 1280: switch (c) {
1.146 ! ratchov 1281: case 'b':
! 1282: if (!opt_num(optarg, 1, RATE_MAX, &bufsz))
! 1283: return 1;
1.74 ratchov 1284: break;
1.15 ratchov 1285: case 'c':
1.146 ! ratchov 1286: if (!opt_ch(optarg, &cmin, &cmax))
! 1287: return 1;
1.15 ratchov 1288: break;
1.146 ! ratchov 1289: case 'd':
! 1290: log_level++;
1.15 ratchov 1291: break;
1292: case 'e':
1.146 ! ratchov 1293: if (!opt_enc(optarg, &par))
! 1294: return 1;
1.15 ratchov 1295: break;
1.146 ! ratchov 1296: case 'f':
! 1297: dev = optarg;
1.15 ratchov 1298: break;
1.146 ! ratchov 1299: case 'h':
! 1300: if (!opt_hdr(optarg, &hdr))
! 1301: return 1;
1.35 ratchov 1302: break;
1.15 ratchov 1303: case 'i':
1.146 ! ratchov 1304: if (!slot_new(optarg, SIO_PLAY,
! 1305: &par, hdr, cmin, cmax, rate, dup, vol))
! 1306: return 1;
! 1307: mode |= SIO_PLAY;
1.15 ratchov 1308: break;
1.146 ! ratchov 1309: case 'j':
! 1310: if (!opt_onoff(optarg, &dup))
! 1311: return 1;
1.92 ratchov 1312: break;
1.146 ! ratchov 1313: case 'n':
! 1314: n_flag = 1;
1.4 millert 1315: break;
1.146 ! ratchov 1316: case 'o':
! 1317: if (!slot_new(optarg, SIO_REC,
! 1318: &par, hdr, cmin, cmax, rate, dup, 0))
! 1319: return 1;
! 1320: mode |= SIO_REC;
1.74 ratchov 1321: break;
1.146 ! ratchov 1322: case 'q':
! 1323: port = optarg;
1.120 ratchov 1324: break;
1.146 ! ratchov 1325: case 'r':
! 1326: if (!opt_num(optarg, RATE_MIN, RATE_MAX, &rate))
! 1327: return 1;
1.120 ratchov 1328: break;
1.146 ! ratchov 1329: case 'v':
! 1330: if (!opt_num(optarg, 0, MIDI_MAXCTL, &vol))
! 1331: return 1;
1.92 ratchov 1332: break;
1.11 jaredy 1333: default:
1.146 ! ratchov 1334: goto bad_usage;
1.4 millert 1335: }
1336: }
1337: argc -= optind;
1338: argv += optind;
1.146 ! ratchov 1339: if (argc != 0) {
! 1340: bad_usage:
! 1341: log_puts(usagestr);
! 1342: return 1;
! 1343: }
! 1344: if (n_flag) {
! 1345: if (dev != NULL || port != NULL) {
! 1346: log_puts("-f and -q make no sense in off-line mode\n");
! 1347: return 1;
1.125 ratchov 1348: }
1.146 ! ratchov 1349: if (mode != (SIO_PLAY | SIO_REC)) {
! 1350: log_puts("both -i and -o required\n");
! 1351: return 0;
! 1352: }
! 1353: if (!offline())
! 1354: return 1;
1.125 ratchov 1355: } else {
1.146 ! ratchov 1356: if (dev == NULL)
! 1357: dev = SIO_DEVANY;
! 1358: if (mode == 0) {
! 1359: log_puts("at least of -i and -o required\n");
! 1360: return 1;
! 1361: }
! 1362: if (!playrec(dev, mode, bufsz, port))
! 1363: return 1;
1.120 ratchov 1364: }
1.61 ratchov 1365: return 0;
1.1 kstailey 1366: }
![[BACK]](/icons/back.gif){kind=icon}
Return to aucat.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / aucat