Annotation of src/usr.bin/aucat/aparams.c, Revision 1.15
1.15 ! deraadt 1: /* $OpenBSD: aparams.c,v 1.14 2012/04/11 06:05:43 ratchov Exp $ */
1.1 ratchov 2: /*
3: * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
1.15 ! deraadt 17:
! 18: #include <endian.h>
1.1 ratchov 19:
20: #include "aparams.h"
1.10 ratchov 21: #ifdef DEBUG
22: #include "dbg.h"
23: #endif
1.4 ratchov 24:
25: int aparams_ctltovol[128] = {
26: 0,
27: 256, 266, 276, 287, 299, 310, 323, 335,
28: 348, 362, 376, 391, 406, 422, 439, 456,
29: 474, 493, 512, 532, 553, 575, 597, 621,
30: 645, 670, 697, 724, 753, 782, 813, 845,
31: 878, 912, 948, 985, 1024, 1064, 1106, 1149,
32: 1195, 1241, 1290, 1341, 1393, 1448, 1505, 1564,
33: 1625, 1689, 1756, 1825, 1896, 1971, 2048, 2128,
34: 2212, 2299, 2389, 2483, 2580, 2682, 2787, 2896,
35: 3010, 3128, 3251, 3379, 3511, 3649, 3792, 3941,
36: 4096, 4257, 4424, 4598, 4778, 4966, 5161, 5363,
37: 5574, 5793, 6020, 6256, 6502, 6757, 7023, 7298,
38: 7585, 7883, 8192, 8514, 8848, 9195, 9556, 9931,
39: 10321, 10726, 11148, 11585, 12040, 12513, 13004, 13515,
40: 14045, 14596, 15170, 15765, 16384, 17027, 17696, 18390,
41: 19112, 19863, 20643, 21453, 22295, 23170, 24080, 25025,
42: 26008, 27029, 28090, 29193, 30339, 31530, 32768
43: };
1.8 ratchov 44:
45: /*
46: * Fake parameters for byte-streams
47: */
48: struct aparams aparams_none = { 1, 0, 0, 0, 0, 0, 0, 0 };
1.1 ratchov 49:
1.13 ratchov 50: #ifdef DEBUG
1.1 ratchov 51: /*
1.2 ratchov 52: * Generate a string corresponding to the encoding in par,
1.7 ratchov 53: * return the length of the resulting string.
1.2 ratchov 54: */
55: int
56: aparams_enctostr(struct aparams *par, char *ostr)
57: {
58: char *p = ostr;
59:
60: *p++ = par->sig ? 's' : 'u';
61: if (par->bits > 9)
62: *p++ = '0' + par->bits / 10;
63: *p++ = '0' + par->bits % 10;
64: if (par->bps > 1) {
65: *p++ = par->le ? 'l' : 'b';
66: *p++ = 'e';
67: if (par->bps != APARAMS_BPS(par->bits) ||
68: par->bits < par->bps * 8) {
69: *p++ = par->bps + '0';
70: if (par->bits < par->bps * 8) {
71: *p++ = par->msb ? 'm' : 'l';
72: *p++ = 's';
73: *p++ = 'b';
74: }
75: }
76: }
77: *p++ = '\0';
78: return p - ostr - 1;
79: }
1.13 ratchov 80: #endif /* DEBUG */
1.2 ratchov 81:
82: /*
83: * Parse an encoding string, examples: s8, u8, s16, s16le, s24be ...
1.7 ratchov 84: * set *istr to the char following the encoding. Return the number
85: * of bytes consumed.
1.2 ratchov 86: */
87: int
88: aparams_strtoenc(struct aparams *par, char *istr)
89: {
90: char *p = istr;
91: int i, sig, bits, le, bps, msb;
1.6 ratchov 92:
1.2 ratchov 93: #define IS_SEP(c) \
94: (((c) < 'a' || (c) > 'z') && \
95: ((c) < 'A' || (c) > 'Z') && \
96: ((c) < '0' || (c) > '9'))
97:
98: /*
99: * get signedness
100: */
101: if (*p == 's') {
102: sig = 1;
103: } else if (*p == 'u') {
104: sig = 0;
105: } else
106: return 0;
107: p++;
1.6 ratchov 108:
1.2 ratchov 109: /*
110: * get number of bits per sample
111: */
112: bits = 0;
113: for (i = 0; i < 2; i++) {
114: if (*p < '0' || *p > '9')
115: break;
116: bits = (bits * 10) + *p - '0';
117: p++;
118: }
119: if (bits < BITS_MIN || bits > BITS_MAX)
120: return 0;
121: bps = APARAMS_BPS(bits);
122: msb = 1;
1.12 ratchov 123: le = ADATA_LE;
1.2 ratchov 124:
125: /*
1.7 ratchov 126: * get (optional) endianness
1.2 ratchov 127: */
128: if (p[0] == 'l' && p[1] == 'e') {
129: le = 1;
130: p += 2;
131: } else if (p[0] == 'b' && p[1] == 'e') {
132: le = 0;
133: p += 2;
134: } else if (IS_SEP(*p)) {
135: goto done;
136: } else
137: return 0;
138:
139: /*
1.7 ratchov 140: * get (optional) number of bytes
1.2 ratchov 141: */
142: if (*p >= '0' && *p <= '9') {
143: bps = *p - '0';
144: if (bps < (bits + 7) / 8 ||
145: bps > (BITS_MAX + 7) / 8)
146: return 0;
147: p++;
148:
149: /*
1.7 ratchov 150: * get (optional) alignement
1.2 ratchov 151: */
152: if (p[0] == 'm' && p[1] == 's' && p[2] == 'b') {
153: msb = 1;
154: p += 3;
155: } else if (p[0] == 'l' && p[1] == 's' && p[2] == 'b') {
156: msb = 0;
157: p += 3;
158: } else if (IS_SEP(*p)) {
159: goto done;
160: } else
161: return 0;
162: } else if (!IS_SEP(*p))
163: return 0;
164:
165: done:
166: par->msb = msb;
167: par->sig = sig;
168: par->bits = bits;
169: par->bps = bps;
170: par->le = le;
171: return p - istr;
172: }
173:
174: /*
1.1 ratchov 175: * Initialise parameters structure with the defaults natively supported
176: * by the machine.
177: */
178: void
1.14 ratchov 179: aparams_init(struct aparams *par, unsigned int cmin, unsigned int cmax,
180: unsigned int rate)
1.1 ratchov 181: {
1.11 ratchov 182: par->bps = sizeof(adata_t);
183: par->bits = ADATA_BITS;
1.12 ratchov 184: par->le = ADATA_LE;
1.11 ratchov 185: par->sig = 1;
1.12 ratchov 186: par->msb = 0;
1.1 ratchov 187: par->cmin = cmin;
188: par->cmax = cmax;
189: par->rate = rate;
190: }
191:
1.10 ratchov 192: #ifdef DEBUG
193: /*
194: * Print the format/channels/encoding on stderr.
195: */
196: void
197: aparams_dbg(struct aparams *par)
198: {
199: char enc[ENCMAX];
200:
201: aparams_enctostr(par, enc);
202: dbg_puts(enc);
203: dbg_puts(",");
204: dbg_putu(par->cmin);
205: dbg_puts(":");
206: dbg_putu(par->cmax);
207: dbg_puts(",");
208: dbg_putu(par->rate);
209: }
210: #endif
1.1 ratchov 211:
212: /*
1.3 ratchov 213: * Return true if both encodings are the same.
1.1 ratchov 214: */
215: int
1.3 ratchov 216: aparams_eqenc(struct aparams *par1, struct aparams *par2)
1.1 ratchov 217: {
218: if (par1->bps != par2->bps ||
219: par1->bits != par2->bits ||
1.3 ratchov 220: par1->sig != par2->sig)
1.1 ratchov 221: return 0;
222: if ((par1->bits != 8 * par1->bps) && par1->msb != par2->msb)
223: return 0;
224: if (par1->bps > 1 && par1->le != par2->le)
225: return 0;
226: return 1;
1.3 ratchov 227: }
228:
229: /*
1.7 ratchov 230: * Grow channels range and sample rate of ``set'' in order ``subset'' to
1.5 ratchov 231: * become an actual subset of it.
232: */
233: void
234: aparams_grow(struct aparams *set, struct aparams *subset)
235: {
236: if (set->cmin > subset->cmin)
237: set->cmin = subset->cmin;
238: if (set->cmax < subset->cmax)
239: set->cmax = subset->cmax;
240: if (set->rate < subset->rate)
241: set->rate = subset->rate;
242: }
243:
244: /*
1.7 ratchov 245: * Return true if rates are the same.
1.3 ratchov 246: */
247: int
248: aparams_eqrate(struct aparams *p1, struct aparams *p2)
249: {
250: /* XXX: allow 1/9 halftone of difference */
251: return p1->rate == p2->rate;
252: }
253:
1.1 ratchov 254:
255: /*
256: * Return the number of bytes per frame with the given parameters.
257: */
1.14 ratchov 258: unsigned int
1.1 ratchov 259: aparams_bpf(struct aparams *par)
260: {
261: return (par->cmax - par->cmin + 1) * par->bps;
262: }
1.2 ratchov 263:
264: void
265: aparams_copyenc(struct aparams *dst, struct aparams *src)
266: {
267: dst->sig = src->sig;
268: dst->le = src->le;
269: dst->msb = src->msb;
270: dst->bits = src->bits;
271: dst->bps = src->bps;
272: }