Annotation of src/usr.bin/aucat/aparams.c, Revision 1.2
1.2 ! ratchov 1: /* $OpenBSD: aparams.c,v 1.1 2008/05/23 07:15:46 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: */
17:
18: #include <stdio.h>
19: #include <stdlib.h>
20: #include <string.h>
21:
22: #include "aparams.h"
23:
24: /*
1.2 ! ratchov 25: * Generate a string corresponding to the encoding in par,
! 26: * return the length of the resulting string
! 27: */
! 28: int
! 29: aparams_enctostr(struct aparams *par, char *ostr)
! 30: {
! 31: char *p = ostr;
! 32:
! 33: *p++ = par->sig ? 's' : 'u';
! 34: if (par->bits > 9)
! 35: *p++ = '0' + par->bits / 10;
! 36: *p++ = '0' + par->bits % 10;
! 37: if (par->bps > 1) {
! 38: *p++ = par->le ? 'l' : 'b';
! 39: *p++ = 'e';
! 40: if (par->bps != APARAMS_BPS(par->bits) ||
! 41: par->bits < par->bps * 8) {
! 42: *p++ = par->bps + '0';
! 43: if (par->bits < par->bps * 8) {
! 44: *p++ = par->msb ? 'm' : 'l';
! 45: *p++ = 's';
! 46: *p++ = 'b';
! 47: }
! 48: }
! 49: }
! 50: *p++ = '\0';
! 51: return p - ostr - 1;
! 52: }
! 53:
! 54: /*
! 55: * Parse an encoding string, examples: s8, u8, s16, s16le, s24be ...
! 56: * set *istr to the char following the encoding. Retrun the number
! 57: * of bytes consumed
! 58: */
! 59: int
! 60: aparams_strtoenc(struct aparams *par, char *istr)
! 61: {
! 62: char *p = istr;
! 63: int i, sig, bits, le, bps, msb;
! 64:
! 65: #define IS_SEP(c) \
! 66: (((c) < 'a' || (c) > 'z') && \
! 67: ((c) < 'A' || (c) > 'Z') && \
! 68: ((c) < '0' || (c) > '9'))
! 69:
! 70: /*
! 71: * get signedness
! 72: */
! 73: if (*p == 's') {
! 74: sig = 1;
! 75: } else if (*p == 'u') {
! 76: sig = 0;
! 77: } else
! 78: return 0;
! 79: p++;
! 80:
! 81: /*
! 82: * get number of bits per sample
! 83: */
! 84: bits = 0;
! 85: for (i = 0; i < 2; i++) {
! 86: if (*p < '0' || *p > '9')
! 87: break;
! 88: bits = (bits * 10) + *p - '0';
! 89: p++;
! 90: }
! 91: if (bits < BITS_MIN || bits > BITS_MAX)
! 92: return 0;
! 93: bps = APARAMS_BPS(bits);
! 94: msb = 1;
! 95: le = NATIVE_LE;
! 96:
! 97: /*
! 98: * get (optionnal) endianness
! 99: */
! 100: if (p[0] == 'l' && p[1] == 'e') {
! 101: le = 1;
! 102: p += 2;
! 103: } else if (p[0] == 'b' && p[1] == 'e') {
! 104: le = 0;
! 105: p += 2;
! 106: } else if (IS_SEP(*p)) {
! 107: goto done;
! 108: } else
! 109: return 0;
! 110:
! 111: /*
! 112: * get (optionnal) number of bytes
! 113: */
! 114: if (*p >= '0' && *p <= '9') {
! 115: bps = *p - '0';
! 116: if (bps < (bits + 7) / 8 ||
! 117: bps > (BITS_MAX + 7) / 8)
! 118: return 0;
! 119: p++;
! 120:
! 121: /*
! 122: * get (optionnal) alignement
! 123: */
! 124: if (p[0] == 'm' && p[1] == 's' && p[2] == 'b') {
! 125: msb = 1;
! 126: p += 3;
! 127: } else if (p[0] == 'l' && p[1] == 's' && p[2] == 'b') {
! 128: msb = 0;
! 129: p += 3;
! 130: } else if (IS_SEP(*p)) {
! 131: goto done;
! 132: } else
! 133: return 0;
! 134: } else if (!IS_SEP(*p))
! 135: return 0;
! 136:
! 137: done:
! 138: par->msb = msb;
! 139: par->sig = sig;
! 140: par->bits = bits;
! 141: par->bps = bps;
! 142: par->le = le;
! 143: return p - istr;
! 144: }
! 145:
! 146: /*
1.1 ratchov 147: * Initialise parameters structure with the defaults natively supported
148: * by the machine.
149: */
150: void
151: aparams_init(struct aparams *par, unsigned cmin, unsigned cmax, unsigned rate)
152: {
153: par->bps = 2; /* 2 bytes per sample */
154: par->bits = 16; /* 16 significant bits per sample */
155: par->sig = 1; /* samples are signed */
156: par->le = NATIVE_LE;
157: par->msb = 1; /* msb justified */
158: par->cmin = cmin;
159: par->cmax = cmax;
160: par->rate = rate;
161: }
162:
163: /*
164: * Print the format/channels/encoding on stderr.
165: */
166: void
167: aparams_print(struct aparams *par)
168: {
1.2 ! ratchov 169: char enc[ENCMAX];
! 170:
! 171: aparams_enctostr(par, enc);
! 172: fprintf(stderr, "%s", enc);
1.1 ratchov 173: fprintf(stderr, ",%u:%u", par->cmin, par->cmax);
174: fprintf(stderr, ",%uHz", par->rate);
175: }
176:
177: void
178: aparams_print2(struct aparams *par1, struct aparams *par2)
179: {
180: aparams_print(par1);
181: fprintf(stderr, " -> ");
182: aparams_print(par2);
183: }
184:
185: /*
186: * Return true if both parameters are the same.
187: */
188: int
189: aparams_eq(struct aparams *par1, struct aparams *par2)
190: {
191: if (par1->bps != par2->bps ||
192: par1->bits != par2->bits ||
193: par1->sig != par2->sig ||
194: par1->cmin != par2->cmin ||
195: par1->cmax != par2->cmax ||
196: par1->rate != par2->rate)
197: return 0;
198: if ((par1->bits != 8 * par1->bps) && par1->msb != par2->msb)
199: return 0;
200: if (par1->bps > 1 && par1->le != par2->le)
201: return 0;
202: return 1;
203: }
204:
205: /*
206: * Return the number of bytes per frame with the given parameters.
207: */
208: unsigned
209: aparams_bpf(struct aparams *par)
210: {
211: return (par->cmax - par->cmin + 1) * par->bps;
212: }
1.2 ! ratchov 213:
! 214: void
! 215: aparams_copyenc(struct aparams *dst, struct aparams *src)
! 216: {
! 217: dst->sig = src->sig;
! 218: dst->le = src->le;
! 219: dst->msb = src->msb;
! 220: dst->bits = src->bits;
! 221: dst->bps = src->bps;
! 222: }
! 223:
![[BACK]](/icons/back.gif){kind=icon}
Return to aparams.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / aucat