1 // Copyright (C) 2008-2009 David Sugar, Tycho Softworks.
2 //
3 // This program is free software; you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation; either version 3 of the License, or
6 // (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program. If not, see <http://www.gnu.org/licenses/>.
15
22 #ifndef _BAYONNE_H_
23 #define _BAYONNE_H_
24
25 #define BAYONNE_NAMESPACE bayonne
26 #define NAMESPACE_BAYONNE namespace bayonne {
27
28 #ifndef UCOMMON_UCOMMON_H_
29 #include <ucommon/ucommon.h>
30 #endif
31
49 using namespace UCOMMON_NAMESPACE;
50
56 class __EXPORT Script : public CountedObject, private memalloc
57 {
58 public:
59 class interp;
60 class header;
61 class checks;
62
66 typedef bool (Script::interp::*method_t)(void);
67
74 typedef struct line {
75 struct line *next;
76 union {
77 const char *cmd;
78 header *sub;
79 };
80 char **argv;
81 unsigned short loop, argc;
82 unsigned lnum, mask;
83 method_t method;
84 } line_t;
85
89 typedef const char *(*check_t)(Script *img, Script::header *scr, Script::line_t *line);
90
96 typedef struct keyword
97 {
98 public:
99 const char *name;
100 method_t method;
101 check_t check;
102 struct keyword *next;
103 } keyword_t;
104
112 class __EXPORT strict : public LinkedObject
113 {
114 public:
115 const char *id;
116
117 public:
118 static bool find(Script *img, header *scr, const char *id);
119 static void createVar(Script *img, header *scr, const char *id);
120 static void createSym(Script *img, header *scr, const char *id);
121 static void createAny(Script *img, header *scr, const char *id);
122 static void createGlobal(Script *img, const char *id);
123
124 void put(FILE *fp, const char *header);
125 };
126
134 class __EXPORT symbol : public LinkedObject
135 {
136 public:
137 const char *name;
138 char *data;
139 unsigned size;
140 header *scope;
141 };
142
148 class __EXPORT event : public LinkedObject
149 {
150 public:
151 line_t *first;
152 const char *name;
153 };
154
158 typedef event event_t;
159
168 class __EXPORT header : public LinkedObject
169 {
170 public:
171 LinkedObject *scoped;
172 LinkedObject *events;
173 LinkedObject *methods;
174 line_t *first;
175 const char *name;
176 unsigned resmask;
182 inline void link(header *scr)
183 {next = scr;};
184 };
185
193 class __EXPORT checks
194 {
195 public:
196 static bool isValue(const char *text);
197 static bool isText(const char *text);
198
199 static const char *chkPush(Script *img, header *scr, line_t *line);
200 static const char *chkApply(Script *img, header *scr, line_t *line);
201 static const char *chkIgnore(Script *img, header *scr, line_t *line);
202 static const char *chkNop(Script *img, header *scr, line_t *line);
203 static const char *chkExit(Script *img, header *scr, line_t *line);
204 static const char *chkVar(Script *img, header *scr, line_t *line);
205 static const char *chkConst(Script *img, header *scr, line_t *line);
206 static const char *chkSet(Script *img, header *scr, line_t *line);
207 static const char *chkClear(Script *img, header *scr, line_t *line);
208 static const char *chkError(Script *img, header *scr, line_t *line);
209 static const char *chkPack(Script *img, header *scr, line_t *line);
210 static const char *chkExpand(Script *img, header *scr, line_t *line);
211 static const char *chkGosub(Script *img, header *src, line_t *line);
212 static const char *chkGoto(Script *img, header *scr, line_t *line);
213 static const char *chkDo(Script *img, header *scr, line_t *line);
214 static const char *chkUntil(Script *img, header *scr, line_t *line);
215 static const char *chkWhile(Script *ing, header *scr, line_t *line);
216 static const char *chkConditional(Script *img, header *scr, line_t *line);
217 static const char *chkContinue(Script *img, header *scr, line_t *line);
218 static const char *chkBreak(Script *img, header *scr, line_t *line);
219 static const char *chkLoop(Script *img, header *scr, line_t *line);
220 static const char *chkPrevious(Script *img, header *scr, line_t *line);
221 static const char *chkIndex(Script *img, header *scr, line_t *line);
222 static const char *chkForeach(Script *img, header *scr, line_t *line);
223 static const char *chkCase(Script *img, header *scr, line_t *line);
224 static const char *chkEndcase(Script *img, header *scr, line_t *line);
225 static const char *chkOtherwise(Script *img, header *scr, line_t *line);
226 static const char *chkIf(Script *img, header *scr, line_t *line);
227 static const char *chkElif(Script *img, header *scr, line_t *line);
228 static const char *chkElse(Script *img, header *scr, line_t *line);
229 static const char *chkEndif(Script *img, header *scr, line_t *line);
230 static const char *chkDefine(Script *img, header *scr, line_t *line);
231 static const char *chkInvoke(Script *img, header *scr, line_t *line);
232 static const char *chkWhen(Script *img, header *scr, line_t *line);
233 static const char *chkStrict(Script *img, header *scr, line_t *line);
234 static const char *chkExpr(Script *img, header *scr, line_t *line);
235 static const char *chkRef(Script *ing, header *scr, line_t *line);
236 };
237
242 typedef struct {
243 header *scr;
244 header *scope;
245 event_t *event;
246 line_t *line;
247 unsigned short index;
248 unsigned short base;
249 unsigned short resmask;
250 } stack_t;
251
262 class __EXPORT interp : protected memalloc
263 {
264 public:
265 typedef char num_t[16];
266
267 interp();
268 virtual ~interp();
269
275 bool step(void);
276
285 bool attach(Script *image, const char *entry = NULL);
286
290 void detach(void);
291
297 void initialize(void);
298
303 bool error(const char *text);
304
309 unsigned getResource(void);
310
311 protected:
312 symbol *find(const char *id);
313 void skip(void);
314 void push(void);
315 bool trylabel(const char *id);
316 bool tryexit(void);
317 void pullScope(void);
318 void pullBase(void);
319 void pullLoop(void);
320 bool pop(void);
321 void setStack(header *scr, event *ev = NULL);
322
330 virtual bool match(const char *pattern, const char *name);
331
339 virtual bool isInherited(const char *name);
340
348 bool scriptEvent(const char *name);
349
355 event *scriptMethod(const char *name);
356
357 stack_t *stack;
358 object_pointer<Script> image;
359 LinkedObject **syms;
360 unsigned frame;
361
362 char *getTemp(void);
363 bool setConst(const char *id, const char *value);
364 symbol *createSymbol(const char *id);
365 symbol *getVar(const char *id, const char *value = NULL);
366 const char *getValue(void);
367 const char *getContent(void);
368 const char *getContent(const char *text);
369 const char *getKeyword(const char *id);
370 method_t getLooping(void);
371 bool isConditional(unsigned index);
372 void setRef(header *scope, const char *id, char *data, unsigned size);
373 void getParams(header *scope, line_t *line);
374 void startScript(header *scr);
375
376 virtual unsigned getTypesize(const char *type_id);
377 virtual const char *getTypeinit(const char *type_id);
378 virtual const char *getFormat(symbol *sym, const char *id, char *temp);
379 virtual bool getCondition(const char *test, const char *value);
380 const char *getIndex(void);
381
382 private:
383 bool getExpression(unsigned index);
384
385 char *errmsg;
386 char *temps[3];
387 unsigned tempindex;
388 };
389
396 class __EXPORT error : public OrderedObject
397 {
398 private:
399 friend class Script;
400 error(Script *img, unsigned line, const char *str);
401
402 public:
403 char *errmsg;
404 unsigned errline;
405 };
406
414 class __EXPORT methods : public interp
415 {
416 public:
417 bool scrPush(void);
418 bool scrApply(void);
419 bool scrExpr(void);
420 bool scrVar(void);
421 bool scrSet(void);
422 bool scrAdd(void);
423 bool scrClear(void);
424 bool scrConst(void);
425 bool scrPause(void);
426 bool scrNop(void);
427 bool scrPack(void);
428 bool scrExpand(void);
429 bool scrExit(void);
430 bool scrReturn(void);
431 bool scrError(void);
432 bool scrRestart(void);
433 bool scrGosub(void);
434 bool scrGoto(void);
435 bool scrDo(void);
436 bool scrLoop(void);
437 bool scrUntil(void);
438 bool scrWhile(void);
439 bool scrBreak(void);
440 bool scrContinue(void);
441 bool scrForeach(void);
442 bool scrPrevious(void);
443 bool scrRepeat(void);
444 bool scrIndex(void);
445 bool scrCase(void);
446 bool scrEndcase(void);
447 bool scrOtherwise(void);
448 bool scrIf(void);
449 bool scrElif(void);
450 bool scrElse(void);
451 bool scrEndif(void);
452 bool scrDefine(void);
453 bool scrInvoke(void);
454 bool scrWhen(void);
455 bool scrRef(void);
456 };
457
458 ~Script();
459
460 static unsigned stepping;
461 static unsigned indexing;
462 static size_t paging;
463 static unsigned sizing;
464 static unsigned stacking;
465 static unsigned decimals;
476 static Script *append(Script *merge, const char *filename, Script *config = NULL);
477
486 static Script *compile(const char *filename, Script *config = NULL);
487
488
489
499 static Script *merge(const char *filename, Script *root = NULL);
500
508 static Script *merge(Script *image, Script *root);
509
515 static void assign(keyword_t *list);
516
524 static keyword_t *find(const char *id);
525
529 static void init(void);
530
531 static unsigned offset(const char *list, unsigned index);
532 static void copy(const char *list, char *item, unsigned size);
533 static unsigned count(const char *list);
534 static const char *get(const char *list, unsigned offset);
535 static char *get(char *list, unsigned offset);
536 static header *find(Script *img, const char *id);
537 static bool isEvent(header *scr, const char *id);
538
539 header *first;
540 LinkedObject **scripts;
541
542 bool push(line_t *line);
543 method_t pull(void);
544 method_t looping(void);
545
546 inline unsigned getErrors(void)
547 {return errors;};
548
549 inline LinkedObject *getListing(void)
550 {return errlist.begin();};
551
552 inline const char *getFilename(void)
553 {return filename;};
554
555 inline bool isStrict(void)
556 {return global != NULL;};
557
558 inline unsigned getLines(void)
559 {return lines;};
560
561 private:
562 friend class strict;
563 friend class checks;
564 friend class error;
565 friend class interp;
566 friend class methods;
567
568 Script();
569
570 void errlog(unsigned line, const char *fmt, ...);
571
572 unsigned errors;
573 unsigned loop;
574 unsigned lines;
575 bool thencheck;
576 line_t **stack;
577 LinkedObject *global;
578 OrderedIndex errlist;
579 object_pointer<Script> shared;
580 const char *filename;
581 LinkedObject *headers;
582 };
583
592 class __EXPORT Audio
593 {
594 public:
595 typedef int16_t snd16_t;
596 typedef int32_t snd32_t;
597 typedef int16_t level_t;
598 typedef int16_t sample_t;
599 typedef int16_t *linear_t;
600
601 #if _MSC_VER > 1400 // windows broken dll linkage issue...
602 const static unsigned ndata = (-1);
603 #else
604 const static unsigned ndata;
605 #endif
606
607 typedef struct {
608 float v2;
609 float v3;
610 float fac;
611 } goertzel_state_t;
612
613 typedef struct {
614 int hit1;
615 int hit2;
616 int hit3;
617 int hit4;
618 int mhit;
619
620 goertzel_state_t row_out[4];
621 goertzel_state_t col_out[4];
622 goertzel_state_t row_out2nd[4];
623 goertzel_state_t col_out2nd[4];
624 goertzel_state_t fax_tone;
625 goertzel_state_t fax_tone2nd;
626 float energy;
627
628 int current_sample;
629 char digits[129];
630 int current_digits;
631 int detected_digits;
632 int lost_digits;
633 int digit_hits[16];
634 int fax_hits;
635 } dtmf_detect_state_t;
636
637 typedef struct {
638 float fac;
639 } tone_detection_descriptor_t;
640
641 typedef unsigned char *encoded_t;
642
646 enum Rate {
647 rateUnknown = 0,
648 rate6khz = 6000,
649 rate8khz = 8000,
650 rate11khz = 11025,
651 rate16khz = 16000,
652 rate22khz = 22050,
653 rate32khz = 32000,
654 rate44khz = 44100
655 };
656
657 typedef enum Rate rate_t;
658
662 enum Mode {
663 modeRead,
664 modeReadAny,
665 modeReadOne,
666 modeWrite,
667 modeCache,
668 modeInfo,
669 modeFeed,
670
671 modeAppend, // app specific placeholders...
672 modeCreate
673 };
674
675 typedef enum Mode mode_t;
676
680 enum Encoding {
681 unknownEncoding = 0,
682 g721ADPCM,
683 g722Audio,
684 g722_7bit,
685 g722_6bit,
686 g723_2bit,
687 g723_3bit,
688 g723_5bit,
689 gsmVoice,
690 msgsmVoice,
691 mulawAudio,
692 alawAudio,
693 mp1Audio,
694 mp2Audio,
695 mp3Audio,
696 okiADPCM,
697 voxADPCM,
698 sx73Voice,
699 sx96Voice,
700
701 // Please keep the PCM types at the end of the list -
702 // see the "is this PCM or not?" code in
703 // AudioFile::close for why.
704 cdaStereo,
705 cdaMono,
706 pcm8Stereo,
707 pcm8Mono,
708 pcm16Stereo,
709 pcm16Mono,
710 pcm32Stereo,
711 pcm32Mono,
712
713 // speex codecs
714 speexVoice, // narrow band
715 speexAudio,
716
717 g729Audio,
718 ilbcAudio,
719 speexUltra,
720
721 speexNarrow = speexVoice,
722 speexWide = speexAudio,
723 g723_4bit = g721ADPCM
724 };
725 typedef enum Encoding encoding_t;
726
730 enum Format {
731 raw,
732 snd,
733 riff,
734 wave
735 };
736 typedef enum Format format_t;
737
741 enum Error {
742 errSuccess = 0,
743 errReadLast,
744 errNotOpened,
745 errEndOfFile,
746 errStartOfFile,
747 errRateInvalid,
748 errEncodingInvalid,
749 errReadInterrupt,
750 errWriteInterrupt,
751 errReadFailure,
752 errWriteFailure,
753 errReadIncomplete,
754 errWriteIncomplete,
755 errRequestInvalid,
756 errTOCFailed,
757 errStatFailed,
758 errInvalidTrack,
759 errPlaybackFailed,
760 errNotPlaying,
761 errNoCodec
762 };
763 typedef enum Error error_t;
764
768 class __EXPORT Info
769 {
770 public:
771 format_t format;
772 encoding_t encoding;
773 unsigned long rate;
774 unsigned long bitrate;
775 unsigned order;
776 unsigned framesize, framecount, headersize, padding;
777 timeout_t framing;
778 char *annotation;
779
780 Info();
781 void clear(void);
782 void set(void);
783 void setFraming(timeout_t frame);
784 void setRate(rate_t rate);
785 };
786
787 typedef Info info_t;
788
795 static level_t tolevel(float dbm);
796
803 static float todbm(level_t power);
804
812 static bool is_available(unsigned device = 0);
813
821 static const char *getMIME(Info &info);
822
830 static const char *getName(encoding_t encoding);
831
839 static const char *getExtension(encoding_t encoding);
840
851 static encoding_t getEncoding(const char *name);
852
859 static encoding_t getStereo(encoding_t encoding);
860
867 static encoding_t getMono(encoding_t encoding);
868
875 static bool is_linear(encoding_t encoding);
876
885 static bool is_buffered(encoding_t encoding);
886
893 static bool is_mono(encoding_t encoding);
894
901 static bool is_stereo(encoding_t encoding);
902
910 static rate_t getRate(encoding_t encoding);
911
920 static rate_t getRate(encoding_t e, rate_t request);
921
929 static timeout_t getFraming(encoding_t encoding, timeout_t timeout = 0);
930
938 static timeout_t getFraming(Info &info, timeout_t timeout = 0);
939
947 static bool is_endian(encoding_t encoding);
948
956 static bool is_endian(Info &info);
957
967 static bool swapEndian(encoding_t encoding, void *buffer, unsigned number);
968
977 static void swapEncoded(Info &info, encoded_t data, size_t bytes);
978
989 static bool swapEndian(Info &info, void *buffer, unsigned number);
990
999 static level_t impulse(encoding_t encoding, void *buffer, unsigned number);
1000
1009 static level_t impulse(Info &info, void *buffer, unsigned number = 0);
1010
1020 static level_t peak(encoding_t encoding, void *buffer, unsigned number);
1021
1031 static level_t peak(Info &info, void *buffer, unsigned number = 0);
1032
1040 static void toTimestamp(timeout_t duration, char *address, size_t size);
1041
1048 static timeout_t toTimeout(const char *timestamp);
1049
1072 static int getFrame(encoding_t encoding, int samples = 0);
1073
1086 static int getCount(encoding_t encoding);
1087
1096 static unsigned long toSamples(encoding_t encoding, size_t bytes);
1097
1106 static unsigned long toSamples(Info &info, size_t bytes);
1107
1116 static size_t toBytes(Info &info, unsigned long number);
1117
1126 static size_t toBytes(encoding_t encoding, unsigned long number);
1127
1136 static void fill(unsigned char *address, int number, encoding_t encoding);
1137
1145 static size_t maxFramesize(Info &info);
1146
1154 class __EXPORT resample
1155 {
1156 protected:
1157 unsigned mfact, dfact, max;
1158 unsigned gpos, ppos;
1159 sample_t last;
1160 linear_t buffer;
1161
1162 public:
1163 resample(rate_t mul, rate_t div);
1164 ~resample();
1165
1166 size_t process(linear_t from, linear_t to, size_t count);
1167 size_t estimate(size_t count);
1168 };
1169 };
1170
1177 class __EXPORT
Phrasebook :
public LinkedObject
1178 {
1179 public:
1180 typedef struct
1181 {
1182 bool zeroflag;
1183 unsigned long last;
1184 unsigned pos;
1185 unsigned max;
1186 size_t size;
1187 char *bp;
1188 const char *list[1];
1189 } rule_t;
1190
1191 protected:
1192 static void _add(
const char *text, rule_t *
state);
1193
1194 static void _dup(
const char *text, rule_t *
state);
1195
1196 static void _lownumber(
int num, rule_t *
state);
1197
1198 public:
1200
1201 virtual bool id(const char *lang) = 0;
1202
1203 virtual const char *path(void);
1204
1205 virtual void number(
const char *text, rule_t *
state);
1206
1207 virtual void order(
const char *text, rule_t *
state);
1208
1209 virtual void spell(
const char *text, rule_t *
state);
1210
1211 virtual void literal(
const char *text, rule_t *
state);
1212
1213 virtual void weekday(
const char *text, rule_t *
state);
1214
1215 virtual void date(
const char *text, rule_t *
state);
1216
1217 virtual void fulldate(
const char *text, rule_t *
state);
1218
1219 virtual void year(
const char *text, rule_t *
state);
1220
1221 virtual void time(
const char *text, rule_t *
state);
1222
1223 virtual void zero(
const char *text, rule_t *
state);
1224
1225 virtual void single(
const char *text, rule_t *
state);
1226
1227 virtual void plural(
const char *text, rule_t *
state);
1228
1229 virtual void nonzero(
const char *text, rule_t *
state);
1230
1231 static Phrasebook *find(
const char *locale = NULL);
1232
1233 static void init(rule_t *
state,
size_t size);
1234
1235 static void reset(rule_t *
state);
1236
1237 };
1238
1243 class __EXPORT Env
1244 {
1245 private:
1246 static shell_t *sys;
1247 static bool daemon_flag;
1248 static bool tool_flag;
1249
1250 public:
1251 class __LOCAL pathinfo_t
1252 {
1253 public:
1255 const char *voices;
1256 const char *appname;
1257
1258 inline pathinfo_t()
1259 {book = NULL; voices = appname = NULL;};
1260
1261 inline void reset(void)
1262 {book = NULL; voices = appname = NULL;};
1263
1265 {return book;};
1266 };
1267
1268 static void init(shell_t *args);
1269
1270 static void tool(shell_t *args);
1271
1272 static inline void set(const char *id, const char *value)
1273 {sys->setsym(id, value);};
1274
1275 static inline const char *get(const char *id)
1276 {return sys->getsym(id);};
1277
1278 static inline const char *env(const char *id)
1279 {return sys->getsym(id);};
1280
1281 static const char *config(const char *name);
1282
1283 static const char *path(pathinfo_t& pathinfo, const char *path, char *buffer, size_t size, bool write = false);
1284 };
1285
1294 class __EXPORT Tonegen : public Audio, protected Env
1295 {
1296 public:
1297 typedef struct _tonedef {
1298 struct _tonedef *next;
1299 timeout_t duration, silence;
1300 unsigned count;
1301 unsigned short f1, f2;
1302 } def_t;
1303
1304 typedef struct _tonekey {
1305 struct _tonekey *next;
1306 struct _tonedef *first;
1307 struct _tonedef *last;
1308 char id[1];
1309 } key_t;
1310
1311 protected:
1312 rate_t rate;
1313 unsigned samples;
1314 linear_t frame;
1315 double df1, df2, p1, p2;
1316 level_t m1, m2;
1317 bool silencer;
1318 bool complete;
1319 key_t *tone;
1320 def_t *def;
1321 unsigned remaining, silent, count;
1322 timeout_t framing;
1323 level_t level;
1324
1328 void silence(void);
1329
1333 void reset(void);
1334
1338 void cleanup(void);
1339
1346 void single(unsigned freq, level_t level);
1347
1356 void dual(unsigned f1, unsigned f2, level_t l1, level_t l2);
1357
1358 public:
1365 Tonegen(timeout_t duration = 20, rate_t rate = rate8khz);
1366
1375 Tonegen(key_t *key, level_t level, timeout_t frame = 20);
1376
1387 Tonegen(unsigned f1, unsigned f2, level_t l1, level_t l2,
1388 timeout_t duration = 20, rate_t sample = rate8khz);
1389
1398 Tonegen(unsigned freq, level_t level, timeout_t duration = 20, rate_t sample = rate8khz);
1399
1400 virtual ~Tonegen();
1401
1407 inline rate_t getRate(void) const
1408 {return rate;};
1409
1415 inline size_t getSamples(void) const
1416 {return samples;};
1417
1423 bool is_silent(void);
1424
1432 virtual linear_t getFrame(void);
1433
1442 unsigned getFrames(linear_t buffer, unsigned number);
1443
1450 inline bool is_complete(void)
1451 {return complete;};
1452
1453 static bool load(const char *locale = NULL);
1454
1455 static key_t *find(const char *id, const char *locale = NULL);
1456 };
1457
1467 class __EXPORT DTMFDialer : public Tonegen
1468 {
1469 protected:
1470 unsigned dtmfframes;
1471 const char *digits;
1472
1473 public:
1482 DTMFDialer(const char *digits, level_t level, timeout_t duration = 20, timeout_t interdigit = 60);
1483
1484 ~DTMFDialer();
1485
1486 linear_t getFrame(void);
1487 };
1488
1498 class __EXPORT MFDialer : public Tonegen
1499 {
1500 protected:
1501 unsigned mfframes;
1502 const char *digits;
1503 bool kflag;
1504
1505 public:
1514 MFDialer(const char *digits, level_t level, timeout_t duration = 20, timeout_t interdigit = 60);
1515
1516 ~MFDialer();
1517
1518 linear_t getFrame(void);
1519 };
1520
1525 class __EXPORT DTMFDetect : public Audio
1526 {
1527 public:
1528 DTMFDetect();
1529 ~DTMFDetect();
1530
1539 int putSamples(linear_t buffer, int count);
1540
1547 int getResult(char *data, int size);
1548
1549 protected:
1550 void goertzelInit(goertzel_state_t *s, tone_detection_descriptor_t *t);
1551 void goertzelUpdate(goertzel_state_t *s, sample_t x[], int samples);
1552 float goertzelResult(goertzel_state_t *s);
1553
1554 private:
1555 dtmf_detect_state_t *
state;
1556 tone_detection_descriptor_t dtmf_detect_row[4];
1557 tone_detection_descriptor_t dtmf_detect_col[4];
1558 tone_detection_descriptor_t dtmf_detect_row_2nd[4];
1559 tone_detection_descriptor_t dtmf_detect_col_2nd[4];
1560 tone_detection_descriptor_t fax_detect;
1561 tone_detection_descriptor_t fax_detect_2nd;
1562 };
1563
1576 class __EXPORT
AudioCodec :
public Audio,
public LinkedObject
1577 {
1578 protected:
1579 encoding_t encoding;
1580 const char *name;
1581 info_t info;
1582
1584
1592 virtual AudioCodec *getByFormat(
const char *format)
1593 {return this;};
1594
1602 {return this;};
1603
1604 public:
1611 AudioCodec(
const char *name, encoding_t encoding);
1612
1613 inline const char *getName(void) const
1614 {return name;};
1615
1616 inline const char *getDescription(void) const
1617 {return info.annotation;};
1618
1620
1628
1638 static AudioCodec *
get(encoding_t encoding,
const char *format = NULL);
1639
1648
1657 virtual level_t impulse(void *buffer, unsigned number = 0);
1658
1666 virtual level_t peak(void *buffer, unsigned number = 0);
1667
1678 virtual bool is_silent(level_t threashold, void *buffer, unsigned number = 0);
1679
1688 virtual unsigned encode(linear_t buffer, void *dest, unsigned number = 0) = 0;
1689
1698 virtual unsigned encodeBuffered(linear_t Buffer, encoded_t dest, unsigned number);
1699
1708 virtual unsigned decode(linear_t buffer, void *source, unsigned number = 0) = 0;
1709
1719 virtual unsigned decodeBuffered(linear_t buffer, encoded_t source, unsigned len);
1720
1726 virtual unsigned getEstimated(void);
1727
1733 virtual unsigned getRequired(void);
1734
1744 virtual unsigned getPacket(encoded_t destination, encoded_t data, unsigned size);
1745
1751 inline info_t getInfo(void) const
1752 {return info;};
1753 };
1754
1763 class __EXPORT AudioFile: public Audio
1764 {
1765 protected:
1766 char *pathname;
1767 size_t header; // offset to start of audio
1768 size_t minimum; // minimum sample size required
1769 size_t iolimit;
1770 size_t pos, eof; // saved position mark...
1771 info_t info;
1772 mode_t mode;
1773 fsys_t fs;
1774
1775 void initialize(void);
1776 void getWaveFormat(int size);
1778
1779 ssize_t read(void *buf, size_t len);
1780 ssize_t write(void *buf, size_t len);
1781 ssize_t peek(void *buf, size_t len);
1782 bool seek(size_t pos);
1783
1784 virtual const char *getContinuation();
1785
1795 unsigned short getShort(unsigned char *data) const;
1796
1805 void setShort(unsigned char *data, unsigned short value);
1806
1816 unsigned long getLong(unsigned char *data) const;
1817
1826 void setLong(unsigned char *data, unsigned long value);
1827
1828 public:
1835 AudioFile(const char *name, unsigned long offset = 0);
1836
1844 AudioFile(const char *name, info_t& info, unsigned long minimum = 0);
1845
1849 AudioFile();
1850
1851 virtual ~AudioFile();
1852
1863 void open(const char *name, mode_t mode = modeWrite, timeout_t framing = 0);
1864
1874 void create(const char *name, info_t& info, timeout_t framing = 0);
1875
1882 time_t age(void);
1883
1889 inline size_t getSize(void)
1890 {return maxFramesize(info);};
1891
1897 void close(void);
1898
1906 void clear(void);
1907
1908 inline int err(void)
1909 {return fs.err();};
1910
1922 ssize_t getBuffer(encoded_t buffer, size_t len = 0);
1923
1932 unsigned getLinear(linear_t buffer, unsigned request = 0);
1933
1941 ssize_t getNative(encoded_t data, size_t size);
1942
1954 ssize_t putBuffer(encoded_t buffer, size_t len = 0);
1955
1964 ssize_t putNative(encoded_t data, size_t size);
1965
1974 unsigned putLinear(linear_t buffer, unsigned request = 0);
1975
1988 int getSamples(void *buffer, unsigned samples = 0);
1989
2001 int putSamples(void *buffer, unsigned samples = 0);
2002
2010 int skip(long number);
2011
2019 int setPosition(unsigned long samples = ~0l);
2020
2028 int position(const char *timestamp);
2029
2036 void getPosition(char *timestamp, size_t size);
2037
2044 void setLimit(unsigned long maximum = 0l);
2045
2052 inline void getInfo(info_t& output) const
2053 {output = info;};
2054
2063 int setMinimum(unsigned long minimum);
2064
2074 inline size_t getAbsolutePosition(void)
2075 {return pos;}
2076
2088 unsigned long getPosition(void);
2089
2090 inline bool operator!() const
2091 {return !fs;};
2092
2093 inline operator bool() const
2094 {return is(fs);};
2095
2096 inline bool is_open(void) const
2097 {return is(fs);};
2098
2104 inline encoding_t getEncoding(void) const
2105 {return info.encoding;};
2106
2112 inline format_t getFormat(void) const
2113 {return info.format;};
2114
2121 inline unsigned getSampleRate(void) const
2122 {return info.rate;};
2123
2129 inline char *getAnnotation(void) const
2130 {return info.annotation;};
2131
2137 bool is_signed(void) const;
2138 };
2139
2152 {
2153 protected:
2155 encoded_t framebuf;
2156 bool streamable;
2157 linear_t bufferFrame;
2158 unsigned bufferPosition;
2159 unsigned bufferChannels;
2160 linear_t encBuffer, decBuffer;
2161 unsigned encSize, decSize;
2162
2163 unsigned bufAudio(linear_t samples, unsigned count, unsigned size);
2164
2165 public:
2170
2178 AudioStream(
const char *name, mode_t mode = modeRead, timeout_t framing = 0);
2179
2188 AudioStream(
const char *name, info_t& info, timeout_t framing = 0);
2189
2191
2199 ssize_t getBuffer(encoded_t data, size_t count);
2200
2208 void open(const char *name, mode_t mode = modeRead, timeout_t framing = 0);
2209
2218 void create(const char *name, info_t& info, timeout_t framing = 0);
2219
2223 void close(void);
2224
2228 void flush(void);
2229
2236 bool is_streamable(void);
2237
2241 unsigned getCount(void); // frame count
2242
2252 unsigned getEncoded(
AudioCodec *codec, encoded_t address,
unsigned frames = 1);
2253
2263 unsigned putEncoded(
AudioCodec *codec, encoded_t address,
unsigned frames = 1);
2264
2272 unsigned getEncoded(encoded_t address, unsigned frames = 1);
2273
2281 unsigned putEncoded(encoded_t address, unsigned frames = 1);
2282
2290 ssize_t getPacket(encoded_t data);
2291
2300 unsigned getMono(linear_t buffer, unsigned frames = 1);
2301
2310 unsigned getStereo(linear_t buffer, unsigned frames = 1);
2311
2320 unsigned putMono(linear_t buffer, unsigned frames = 1);
2321
2330 unsigned putStereo(linear_t buffer, unsigned frames = 1);
2331
2341 unsigned bufMono(linear_t buffer, unsigned count);
2342
2352 unsigned bufStereo(linear_t buffer, unsigned count);
2353
2360 {return codec;};
2361 };
2362
2370 class __EXPORT Serial
2371 {
2372 protected:
2373 int error;
2374
2375 Serial();
2376 Serial(const Serial&);
2377
2378 public:
2379 virtual ~Serial();
2380
2381 inline int err(void)
2382 {return error;};
2383
2384 virtual operator bool() = 0;
2385 virtual bool operator!() = 0;
2386 virtual void restore(void) = 0;
2387 virtual bool set(const char *format) = 0;
2388 virtual void dtr(timeout_t toggle_time) = 0;
2389 virtual size_t get(void *addr, size_t len) = 0;
2390 virtual size_t put(void *addr, size_t len) = 0;
2391 virtual void clear(void) = 0;
2392 virtual bool flush(timeout_t timeout) = 0;
2393 virtual bool wait(timeout_t timeout) = 0;
2394 virtual void text(char nl1 = 0x13, char nl2 = 0x10) = 0;
2395 virtual void bin(size_t size, timeout_t timeout = 0) = 0;
2396 virtual void sync(void) = 0;
2397
2398 static Serial *create(const char *name);
2399
2400 static stringpager *list(void);
2401 };
2402
2410 class __EXPORT Module : public LinkedObject, protected Env
2411 {
2412 protected:
2413 virtual void start(void);
2414
2415 virtual void stop(void);
2416
2417 public:
2418 Module();
2419
2420 static void startup(void);
2421 static void shutdown(void);
2422 };
2423
2424 typedef Serial *serial_t;
2425
2426 END_NAMESPACE
2427
2428 #endif
2429
#define NAMESPACE_BAYONNE