00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef __YATEPHONE_H
00026 #define __YATEPHONE_H
00027
00028 #ifndef __cplusplus
00029 #error C++ is required
00030 #endif
00031
00032 #include <yatengine.h>
00033
00037 namespace TelEngine {
00038
00042 struct YATE_API ImageInfo {
00046 int width;
00047
00051 int height;
00052
00056 int depth;
00057 };
00058
00062 struct YATE_API FormatInfo {
00066 const char* name;
00067
00071 const char* type;
00072
00076 int frameSize;
00077
00081 int frameTime;
00082
00086 int sampleRate;
00087
00091 int numChannels;
00092
00096 bool converter;
00097
00103 int guessSamples(int len) const;
00104
00109 int dataRate() const;
00110
00114 inline FormatInfo()
00115 : name(0), type("audio"),
00116 frameSize(0), frameTime(0),
00117 sampleRate(8000), numChannels(1),
00118 converter(false)
00119 { }
00120
00124 inline FormatInfo(const char* _name, int fsize = 0, int ftime = 10000,
00125 const char* _type = "audio", int srate = 8000, int nchan = 1, bool convert = false)
00126 : name(_name), type(_type),
00127 frameSize(fsize), frameTime(ftime),
00128 sampleRate(srate), numChannels(nchan),
00129 converter(convert)
00130 { }
00131 };
00132
00133 class CallEndpoint;
00134 class Driver;
00135
00140 struct YATE_API TranslatorCaps {
00142 const FormatInfo* src;
00144 const FormatInfo* dest;
00146 int cost;
00147 };
00148
00153 class YATE_API FormatRepository
00154 {
00155 private:
00156 FormatRepository();
00157 FormatRepository& operator=(const FormatRepository&);
00158 public:
00164 static const FormatInfo* getFormat(const String& name);
00165
00177 static const FormatInfo* addFormat(const String& name, int fsize, int ftime, const String& type = "audio", int srate = 8000, int nchan = 1);
00178 };
00179
00184 class YATE_API DataFormat : public String
00185 {
00186 public:
00190 inline DataFormat()
00191 : m_parsed(0)
00192 { }
00193
00198 inline DataFormat(const char* value)
00199 : String(value), m_parsed(0)
00200 { }
00201
00206 inline DataFormat(const DataFormat& value)
00207 : String(value), m_parsed(value.getInfo())
00208 { }
00209
00214 inline DataFormat(const String& value)
00215 : String(value), m_parsed(0)
00216 { }
00217
00222 inline DataFormat(const String* value)
00223 : String(value), m_parsed(0)
00224 { }
00225
00230 inline DataFormat(const FormatInfo* format)
00231 : String(format ? format->name : (const char*)0), m_parsed(format)
00232 { }
00233
00237 inline DataFormat& operator=(const DataFormat& value)
00238 { String::operator=(value); return *this; }
00239
00244 const FormatInfo* getInfo() const;
00245
00251 inline int frameSize(int defValue = 0) const
00252 { return getInfo() ? getInfo()->frameSize : defValue; }
00253
00259 inline int frameTime(int defValue = 0) const
00260 { return getInfo() ? getInfo()->frameTime : defValue; }
00261
00268 inline int sampleRate(int defValue = 0) const
00269 { return getInfo() ? getInfo()->sampleRate : defValue; }
00270
00276 inline int numChannels(int defValue = 1) const
00277 { return getInfo() ? getInfo()->numChannels : defValue; }
00278
00279 protected:
00283 virtual void changed();
00284
00285 private:
00286 mutable const FormatInfo* m_parsed;
00287 };
00288
00292 class YATE_API DataNode : public RefObject
00293 {
00294 public:
00299 inline DataNode(const char* format = 0)
00300 : m_format(format), m_timestamp(0)
00301 { }
00302
00308 virtual int costFormat(const DataFormat& format)
00309 { return -1; }
00310
00316 virtual bool setFormat(const DataFormat& format)
00317 { return false; }
00318
00323 inline const DataFormat& getFormat() const
00324 { return m_format; }
00325
00330 inline unsigned long timeStamp() const
00331 { return m_timestamp; }
00332
00333 protected:
00334 DataFormat m_format;
00335 unsigned long m_timestamp;
00336 };
00337
00338 class DataSource;
00339 class DataTranslator;
00340 class TranslatorFactory;
00341 class ThreadedSourcePrivate;
00342
00346 class YATE_API DataConsumer : public DataNode
00347 {
00348 friend class DataSource;
00349
00350 public:
00355 inline DataConsumer(const char* format = "slin")
00356 : DataNode(format),
00357 m_source(0), m_override(0),
00358 m_regularTsDelta(0), m_overrideTsDelta(0), m_lastTsTime(0)
00359 { }
00360
00364 virtual ~DataConsumer();
00365
00371 virtual void* getObject(const String& name) const;
00372
00378 virtual void Consume(const DataBlock& data, unsigned long tStamp) = 0;
00379
00384 inline DataSource* getConnSource() const
00385 { return m_source; }
00386
00391 inline DataSource* getOverSource() const
00392 { return m_override; }
00393
00398 virtual DataSource* getTransSource() const
00399 { return 0; }
00400
00401 protected:
00407 virtual bool synchronize(DataSource* source);
00408
00409 private:
00410 void Consume(const DataBlock& data, unsigned long tStamp, DataSource* source);
00411 DataSource* m_source;
00412 DataSource* m_override;
00413 long m_regularTsDelta;
00414 long m_overrideTsDelta;
00415 u_int64_t m_lastTsTime;
00416 };
00417
00421 class YATE_API DataSource : public DataNode
00422 {
00423 friend class DataTranslator;
00424
00425 public:
00430 inline DataSource(const char* format = "slin")
00431 : DataNode(format), m_translator(0) { }
00432
00436 virtual ~DataSource();
00437
00443 virtual void* getObject(const String& name) const;
00444
00450 void Forward(const DataBlock& data, unsigned long tStamp = (unsigned long)-1);
00451
00458 bool attach(DataConsumer* consumer, bool override = false);
00459
00465 bool detach(DataConsumer* consumer);
00466
00470 void clear();
00471
00476 inline Mutex* mutex()
00477 { return &m_mutex; }
00478
00483 inline DataTranslator* getTranslator() const
00484 { return m_translator; }
00485
00490 void synchronize(unsigned long tStamp);
00491
00492 protected:
00493 DataTranslator* m_translator;
00494 ObjList m_consumers;
00495 Mutex m_mutex;
00496 private:
00497 inline void setTranslator(DataTranslator* translator)
00498 { m_translator = translator; }
00499 bool detachInternal(DataConsumer* consumer);
00500 };
00501
00505 class YATE_API ThreadedSource : public DataSource
00506 {
00507 friend class ThreadedSourcePrivate;
00508 public:
00512 virtual ~ThreadedSource();
00513
00520 bool start(const char* name = "ThreadedSource", Thread::Priority prio = Thread::Normal);
00521
00525 void stop();
00526
00531 Thread* thread() const;
00532
00533 protected:
00538 inline ThreadedSource(const char* format = "slin")
00539 : DataSource(format), m_thread(0) { }
00540
00544 virtual void run() = 0;
00545
00549 virtual void cleanup();
00550
00551 private:
00552 ThreadedSourcePrivate* m_thread;
00553 };
00554
00560 class YATE_API DataTranslator : public DataConsumer
00561 {
00562 friend class TranslatorFactory;
00563 public:
00569 DataTranslator(const char* sFormat, const char* dFormat);
00570
00577 DataTranslator(const char* sFormat, DataSource* source = 0);
00578
00582 ~DataTranslator();
00583
00589 virtual void* getObject(const String& name) const;
00590
00595 virtual DataSource* getTransSource() const
00596 { return m_tsource; }
00597
00602 DataTranslator* getFirstTranslator();
00603
00608 const DataTranslator* getFirstTranslator() const;
00609
00618 static ObjList* srcFormats(const DataFormat& dFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);
00619
00628 static ObjList* destFormats(const DataFormat& sFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);
00629
00636 static bool canConvert(const DataFormat& fmt1, const DataFormat& fmt2 = "slin");
00637
00644 static int cost(const DataFormat& sFormat, const DataFormat& dFormat);
00645
00652 static DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat);
00653
00661 static bool attachChain(DataSource* source, DataConsumer* consumer, bool override = false);
00662
00669 static bool detachChain(DataSource* source, DataConsumer* consumer);
00670
00675 static void setMaxChain(unsigned int maxChain);
00676
00677 protected:
00683 virtual bool synchronize(DataSource* source);
00684
00689 static void install(TranslatorFactory* factory);
00690
00695 static void uninstall(TranslatorFactory* factory);
00696
00697 private:
00698 DataTranslator();
00699 static void compose();
00700 static void compose(TranslatorFactory* factory);
00701 static bool canConvert(const FormatInfo* fmt1, const FormatInfo* fmt2);
00702 DataSource* m_tsource;
00703 static Mutex s_mutex;
00704 static ObjList s_factories;
00705 static unsigned int s_maxChain;
00706 };
00707
00713 class YATE_API TranslatorFactory : public GenObject
00714 {
00715 protected:
00719 inline TranslatorFactory()
00720 { DataTranslator::install(this); }
00721
00722 public:
00726 virtual ~TranslatorFactory();
00727
00732 virtual void removed(const TranslatorFactory* factory);
00733
00740 virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) = 0;
00741
00746 virtual const TranslatorCaps* getCapabilities() const = 0;
00747
00754 virtual bool converts(const DataFormat& sFormat, const DataFormat& dFormat) const;
00755
00760 virtual unsigned int length() const;
00761
00767 virtual bool intermediate(const FormatInfo* info) const;
00768
00773 virtual const FormatInfo* intermediate() const;
00774 };
00775
00781 class YATE_API DataEndpoint : public RefObject
00782 {
00783 public:
00784
00788 DataEndpoint(CallEndpoint* call = 0, const char* name = "audio");
00789
00793 ~DataEndpoint();
00794
00800 virtual void* getObject(const String& name) const;
00801
00806 virtual const String& toString() const;
00807
00812 Mutex* mutex() const;
00813
00818 static Mutex& commonMutex();
00819
00825 bool connect(DataEndpoint* peer);
00826
00831 bool disconnect();
00832
00837 void setSource(DataSource* source = 0);
00838
00843 inline DataSource* getSource() const
00844 { return m_source; }
00845
00850 void setConsumer(DataConsumer* consumer = 0);
00851
00856 inline DataConsumer* getConsumer() const
00857 { return m_consumer; }
00858
00864 void setPeerRecord(DataConsumer* consumer = 0);
00865
00870 inline DataConsumer* getPeerRecord() const
00871 { return m_peerRecord; }
00872
00878 void setCallRecord(DataConsumer* consumer = 0);
00879
00884 inline DataConsumer* getCallRecord() const
00885 { return m_callRecord; }
00886
00891 inline DataEndpoint* getPeer() const
00892 { return m_peer; }
00893
00898 inline CallEndpoint* getCall() const
00899 { return m_call; }
00900
00905 inline const String& name() const
00906 { return m_name; }
00907
00908 protected:
00914 virtual bool nativeConnect(DataEndpoint* peer)
00915 { return false; }
00916
00917 private:
00918 String m_name;
00919 DataSource* m_source;
00920 DataConsumer* m_consumer;
00921 DataEndpoint* m_peer;
00922 CallEndpoint* m_call;
00923 DataConsumer* m_peerRecord;
00924 DataConsumer* m_callRecord;
00925 };
00926
00931 class YATE_API CallEndpoint : public RefObject
00932 {
00933 friend class DataEndpoint;
00934
00935 private:
00936 CallEndpoint* m_peer;
00937 String m_id;
00938
00939 protected:
00940 ObjList m_data;
00941 Mutex* m_mutex;
00942
00943 public:
00947 virtual ~CallEndpoint();
00948
00954 virtual void* getObject(const String& name) const;
00955
00960 virtual const String& toString() const
00961 { return m_id; }
00962
00967 inline const String& id() const
00968 { return m_id; }
00969
00974 inline CallEndpoint* getPeer() const
00975 { return m_peer; }
00976
00981 inline const String& getPeerId() const
00982 { return m_peer ? m_peer->id() : String::empty(); }
00983
00988 inline Mutex* mutex() const
00989 { return m_mutex; }
00990
00995 static Mutex& commonMutex();
00996
01004 bool connect(CallEndpoint* peer, const char* reason = 0, bool notify = true);
01005
01012 inline bool disconnect(const char* reason = 0, bool notify = true)
01013 { return disconnect(false,reason,notify); }
01014
01020 DataEndpoint* getEndpoint(const char* type = "audio") const;
01021
01027 DataEndpoint* setEndpoint(const char* type = "audio");
01028
01033 void clearEndpoint(const char* type = 0);
01034
01040 void setSource(DataSource* source = 0, const char* type = "audio");
01041
01047 DataSource* getSource(const char* type = "audio") const;
01048
01054 void setConsumer(DataConsumer* consumer = 0, const char* type = "audio");
01055
01061 DataConsumer* getConsumer(const char* type = "audio") const;
01062
01063 protected:
01067 CallEndpoint(const char* id = 0);
01068
01073 virtual void connected(const char* reason) { }
01074
01080 virtual void disconnected(bool final, const char* reason) { }
01081
01088 void setPeer(CallEndpoint* peer, const char* reason = 0, bool notify = true);
01089
01094 virtual void setId(const char* newId);
01095
01096 private:
01097 bool disconnect(bool final, const char* reason, bool notify);
01098 };
01099
01104 class YATE_API Module : public Plugin, public Mutex, public MessageReceiver, public DebugEnabler
01105 {
01106 private:
01107 bool m_init;
01108 int m_relays;
01109 String m_name;
01110 String m_type;
01111 Regexp m_filter;
01112 u_int64_t m_changed;
01113 static unsigned int s_delay;
01114
01115 public:
01121 virtual void* getObject(const String& name) const;
01122
01127 inline const String& name() const
01128 { return m_name; }
01129
01134 inline const String& type() const
01135 { return m_type; }
01136
01141 void changed();
01142
01147 inline static unsigned int updateDelay()
01148 { return s_delay; }
01149
01154 inline static void updateDelay(unsigned int delay)
01155 { s_delay = delay; }
01156
01161 inline bool filterInstalled() const
01162 { return !m_filter.null(); }
01163
01169 bool filterDebug(const String& item) const;
01170
01171 protected:
01175 enum {
01176
01177 Status = 0x00000001,
01178 Timer = 0x00000002,
01179 Level = 0x00000004,
01180 Command = 0x00000008,
01181 Help = 0x00000010,
01182 Halt = 0x00000020,
01183 Route = 0x00000040,
01184
01185 Execute = 0x00000100,
01186 Drop = 0x00000200,
01187
01188 Locate = 0x00000400,
01189 Masquerade = 0x00000800,
01190 Ringing = 0x00001000,
01191 Answered = 0x00002000,
01192 Tone = 0x00004000,
01193 Text = 0x00008000,
01194 Progress = 0x00010000,
01195 Update = 0x00020000,
01196 Transfer = 0x00040000,
01197
01198 PubLast = 0x0fffffff,
01199
01200 Private = 0x10000000
01201 } RelayID;
01202
01208 static const char* messageName(int id);
01209
01215 Module(const char* name, const char* type = 0);
01216
01220 virtual ~Module();
01221
01225 virtual void initialize();
01226
01230 void setup();
01231
01238 bool installRelay(int id, unsigned priority = 100);
01239
01246 bool installRelay(const char* name, unsigned priority = 100);
01247
01254 virtual bool received(Message &msg, int id);
01255
01260 virtual void genUpdate(Message& msg);
01261
01266 virtual void msgTimer(Message& msg);
01267
01272 virtual void msgStatus(Message& msg);
01273
01278 virtual bool msgRoute(Message& msg);
01279
01284 virtual void statusModule(String& str);
01285
01290 virtual void statusParams(String& str);
01291
01297 virtual bool setDebug(Message& msg, const String& target);
01298
01299 private:
01300 Module();
01301 static TokenDict s_messages[];
01302 bool installRelay(const char* name, int id, unsigned priority);
01303 };
01304
01309 class YATE_API Channel : public CallEndpoint, public DebugEnabler
01310 {
01311 friend class Driver;
01312 friend class Router;
01313
01314 private:
01315 Driver* m_driver;
01316 bool m_outgoing;
01317 u_int64_t m_timeout;
01318 u_int64_t m_maxcall;
01319
01320 protected:
01321 String m_status;
01322 String m_address;
01323 String m_targetid;
01324 String m_billid;
01325 bool m_answered;
01326
01327 public:
01331 virtual ~Channel();
01332
01338 virtual void* getObject(const String& name) const;
01339
01345 virtual void complete(Message& msg, bool minimal = false) const;
01346
01354 Message* message(const char* name, bool minimal = false, bool data = false);
01355
01361 virtual bool msgProgress(Message& msg);
01362
01368 virtual bool msgRinging(Message& msg);
01369
01375 virtual bool msgAnswered(Message& msg);
01376
01383 virtual bool msgTone(Message& msg, const char* tone);
01384
01391 virtual bool msgText(Message& msg, const char* text);
01392
01399 virtual bool msgDrop(Message& msg, const char* reason);
01400
01406 virtual bool msgTransfer(Message& msg);
01407
01413 virtual bool msgUpdate(Message& msg);
01414
01419 virtual void msgStatus(Message& msg);
01420
01426 virtual void checkTimers(Message& msg, const Time& tmr);
01427
01434 virtual bool callPrerouted(Message& msg, bool handled);
01435
01441 virtual bool callRouted(Message& msg);
01442
01447 virtual void callAccept(Message& msg);
01448
01455 virtual void callRejected(const char* error, const char* reason = 0, const Message* msg = 0);
01456
01461 virtual bool setDebug(Message& msg);
01462
01467 inline const String& status() const
01468 { return m_status; }
01469
01474 inline const String& address() const
01475 { return m_address; }
01476
01481 inline bool isOutgoing() const
01482 { return m_outgoing; }
01483
01488 inline bool isIncoming() const
01489 { return !m_outgoing; }
01490
01495 inline bool isAnswered() const
01496 { return m_answered; }
01497
01502 const char* direction() const;
01503
01508 inline Driver* driver() const
01509 { return m_driver; }
01510
01515 inline u_int64_t timeout() const
01516 { return m_timeout; }
01517
01522 inline void timeout(u_int64_t tout)
01523 { m_timeout = tout; }
01524
01529 inline u_int64_t maxcall() const
01530 { return m_maxcall; }
01531
01536 inline void maxcall(u_int64_t tout)
01537 { m_maxcall = tout; }
01538
01543 inline void setMaxcall(const Message& msg)
01544 { setMaxcall(&msg); }
01545
01550 void setMaxcall(const Message* msg);
01551
01557 inline const String& targetid() const
01558 { return m_targetid; }
01559
01565 inline const String& billid() const
01566 { return m_billid; }
01567
01574 bool startRouter(Message* msg);
01575
01580 static unsigned int allocId();
01581
01586 void filterDebug(const String& item);
01587
01588 protected:
01592 Channel(Driver* driver, const char* id = 0, bool outgoing = false);
01593
01597 Channel(Driver& driver, const char* id = 0, bool outgoing = false);
01598
01603 void cleanup();
01604
01608 void dropChan();
01609
01614 virtual void zeroRefs();
01615
01620 virtual void connected(const char* reason);
01621
01627 virtual void disconnected(bool final, const char* reason);
01628
01633 virtual void setId(const char* newId);
01634
01640 void status(const char* newstat);
01641
01646 virtual void statusParams(String& str);
01647
01652 inline void setOutgoing(bool outgoing = true)
01653 { m_outgoing = outgoing; }
01654
01661 bool dtmfInband(const char* tone);
01662
01663 private:
01664 void init();
01665 Channel();
01666 };
01667
01672 class YATE_API Driver : public Module
01673 {
01674 friend class Router;
01675 friend class Channel;
01676
01677 private:
01678 bool m_init;
01679 bool m_varchan;
01680 String m_prefix;
01681 ObjList m_chans;
01682 int m_routing;
01683 int m_routed;
01684 int m_total;
01685 unsigned int m_nextid;
01686 int m_timeout;
01687 int m_maxroute;
01688 int m_maxchans;
01689
01690 public:
01696 virtual void* getObject(const String& name) const;
01697
01702 inline const String& prefix() const
01703 { return m_prefix; }
01704
01709 inline bool varchan() const
01710 { return m_varchan; }
01711
01716 inline ObjList& channels()
01717 { return m_chans; }
01718
01724 virtual Channel* find(const String& id) const;
01725
01730 virtual bool isBusy() const;
01731
01736 virtual void dropAll(Message &msg);
01737
01743 virtual bool canAccept(bool routers = true);
01744
01749 virtual bool canRoute();
01750
01755 unsigned int nextid();
01756
01761 inline unsigned int lastid() const
01762 { return m_nextid; }
01763
01768 inline int timeout() const
01769 { return m_timeout; }
01770
01775 inline int routing() const
01776 { return m_routing; }
01777
01782 inline int routed() const
01783 { return m_routed; }
01784
01789 inline int total() const
01790 { return m_total; }
01791
01792 protected:
01798 Driver(const char* name, const char* type = 0);
01799
01803 virtual void initialize();
01804
01810 void setup(const char* prefix = 0, bool minimal = false);
01811
01818 virtual bool received(Message &msg, int id);
01819
01824 virtual void genUpdate(Message& msg);
01825
01832 virtual bool msgExecute(Message& msg, String& dest) = 0;
01833
01838 virtual void msgStatus(Message& msg);
01839
01844 virtual void statusModule(String& str);
01845
01850 virtual void statusParams(String& str);
01851
01856 virtual void statusChannels(String& str);
01857
01863 virtual bool setDebug(Message& msg, const String& target);
01864
01868 virtual void loadLimits();
01869
01874 inline void varchan(bool variable)
01875 { m_varchan = variable; }
01876
01881 inline void timeout(int tout)
01882 { m_timeout = tout; }
01883
01888 inline void maxRoute(int ncalls)
01889 { m_maxroute = ncalls; }
01890
01895 inline void maxChans(int ncalls)
01896 { m_maxchans = ncalls; }
01897
01898 private:
01899 Driver();
01900 };
01901
01906 class YATE_API Router : public Thread
01907 {
01908 private:
01909 Driver* m_driver;
01910 String m_id;
01911 Message* m_msg;
01912
01913 public:
01920 Router(Driver* driver, const char* id, Message* msg);
01921
01925 virtual void run();
01926
01931 virtual bool route();
01932
01936 virtual void cleanup();
01937
01938 protected:
01943 const String& id() const
01944 { return m_id; }
01945 };
01946
01952 YATE_API bool isE164(const char* str);
01953
01954 };
01955
01956 #endif
01957
01958