home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / soundserver.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-09-11  |  77.6 KB  |  2,091 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef SOUNDSERVER_H
  4. #define SOUNDSERVER_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12. #include "kmedia2.h"
  13. #include "core.h"
  14.  
  15. namespace Arts {
  16. enum RealtimeStatus {rtRealtime = 0, rtNoSupport = 1, rtNoWrapper = 2, rtNoRealtime = 3};
  17. }
  18. namespace Arts {
  19. class SampleStorageEntry;
  20. class SampleStorage;
  21. class ByteSoundProducer;
  22. class ByteSoundProducerV2;
  23. class ByteSoundReceiver;
  24. class SimpleSoundServer;
  25. class SoundServer;
  26. class SoundServerV2;
  27. class WavPlayObject;
  28. class GSLPlayObject;
  29. class SoundServerStartup;
  30.  
  31. class ARTS_EXPORT SampleStorageEntry_base : virtual public Arts::Object_base {
  32. public:
  33.     static unsigned long _IID; // interface ID
  34.  
  35.     static SampleStorageEntry_base *_create(const std::string& subClass = "Arts::SampleStorageEntry");
  36.     static SampleStorageEntry_base *_fromString(const std::string& objectref);
  37.     static SampleStorageEntry_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  38.  
  39.     static SampleStorageEntry_base *_fromDynamicCast(const Arts::Object& object);
  40.     inline SampleStorageEntry_base *_copy() {
  41.         assert(_refCnt > 0);
  42.         _refCnt++;
  43.         return this;
  44.     }
  45.  
  46.     virtual std::vector<std::string> _defaultPortsIn() const;
  47.     virtual std::vector<std::string> _defaultPortsOut() const;
  48.  
  49.     void *_cast(unsigned long iid);
  50.  
  51.     virtual std::string name() = 0;
  52.     virtual std::string filename() = 0;
  53.     virtual bool completed() = 0;
  54.     virtual void write(const std::vector<Arts::mcopbyte>& data) = 0;
  55.     virtual void finish() = 0;
  56. };
  57.  
  58. class ARTS_EXPORT SampleStorageEntry_stub : virtual public SampleStorageEntry_base, virtual public Arts::Object_stub {
  59. protected:
  60.     SampleStorageEntry_stub();
  61.  
  62. public:
  63.     SampleStorageEntry_stub(Arts::Connection *connection, long objectID);
  64.  
  65.     std::string name();
  66.     std::string filename();
  67.     bool completed();
  68.     void write(const std::vector<Arts::mcopbyte>& data);
  69.     void finish();
  70. };
  71.  
  72. class ARTS_EXPORT SampleStorageEntry_skel : virtual public SampleStorageEntry_base, virtual public Arts::Object_skel {
  73. protected:
  74.     // emitters for change notifications
  75.     inline void name_changed(const std::string& newValue) {
  76.         _emit_changed("name_changed",newValue);
  77.     }
  78.     inline void filename_changed(const std::string& newValue) {
  79.         _emit_changed("filename_changed",newValue);
  80.     }
  81.     inline void completed_changed(bool newValue) {
  82.         _emit_changed("completed_changed",newValue);
  83.     }
  84.  
  85. public:
  86.     SampleStorageEntry_skel();
  87.  
  88.     static std::string _interfaceNameSkel();
  89.     std::string _interfaceName();
  90.     bool _isCompatibleWith(const std::string& interfacename);
  91.     void _buildMethodTable();
  92.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  93. };
  94.  
  95. }
  96. #include "reference.h"
  97. namespace Arts {
  98. class ARTS_EXPORT SampleStorageEntry : public Arts::Object {
  99. private:
  100.     static Arts::Object_base* _Creator();
  101.     SampleStorageEntry_base *_cache;
  102.     inline SampleStorageEntry_base *_method_call() {
  103.         _pool->checkcreate();
  104.         if(_pool->base) {
  105.             _cache=(SampleStorageEntry_base *)_pool->base->_cast(SampleStorageEntry_base::_IID);
  106.             assert(_cache);
  107.         }
  108.         return _cache;
  109.     }
  110.  
  111. protected:
  112.     inline SampleStorageEntry(SampleStorageEntry_base* b) : Arts::Object(b), _cache(0) {}
  113.  
  114.  
  115. public:
  116.     typedef SampleStorageEntry_base _base_class;
  117.  
  118.     inline SampleStorageEntry() : Arts::Object(_Creator), _cache(0) {}
  119.     inline SampleStorageEntry(const Arts::SubClass& s) :
  120.         Arts::Object(SampleStorageEntry_base::_create(s.string())), _cache(0) {}
  121.     inline SampleStorageEntry(const Arts::Reference &r) :
  122.         Arts::Object(r.isString()?(SampleStorageEntry_base::_fromString(r.string())):(SampleStorageEntry_base::_fromReference(r.reference(),true))), _cache(0) {}
  123.     inline SampleStorageEntry(const Arts::DynamicCast& c) : Arts::Object(SampleStorageEntry_base::_fromDynamicCast(c.object())), _cache(0) {}
  124.     inline SampleStorageEntry(const SampleStorageEntry& target) : Arts::Object(target._pool), _cache(target._cache) {}
  125.     inline SampleStorageEntry(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  126.     inline static SampleStorageEntry null() {return SampleStorageEntry((SampleStorageEntry_base*)0);}
  127.     inline static SampleStorageEntry _from_base(SampleStorageEntry_base* b) {return SampleStorageEntry(b);}
  128.     inline SampleStorageEntry& operator=(const SampleStorageEntry& target) {
  129.         if (_pool == target._pool) return *this;
  130.         _pool->Dec();
  131.         _pool = target._pool;
  132.         _cache = target._cache;
  133.         _pool->Inc();
  134.         return *this;
  135.     }
  136.     inline SampleStorageEntry_base* _base() {return _cache?_cache:_method_call();}
  137.  
  138.     inline std::string name();
  139.     inline std::string filename();
  140.     inline bool completed();
  141.     inline void write(const std::vector<Arts::mcopbyte>& data);
  142.     inline void finish();
  143. };
  144.  
  145. class ARTS_EXPORT SampleStorage_base : virtual public Arts::Object_base {
  146. public:
  147.     static unsigned long _IID; // interface ID
  148.  
  149.     static SampleStorage_base *_create(const std::string& subClass = "Arts::SampleStorage");
  150.     static SampleStorage_base *_fromString(const std::string& objectref);
  151.     static SampleStorage_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  152.  
  153.     static SampleStorage_base *_fromDynamicCast(const Arts::Object& object);
  154.     inline SampleStorage_base *_copy() {
  155.         assert(_refCnt > 0);
  156.         _refCnt++;
  157.         return this;
  158.     }
  159.  
  160.     virtual std::vector<std::string> _defaultPortsIn() const;
  161.     virtual std::vector<std::string> _defaultPortsOut() const;
  162.  
  163.     void *_cast(unsigned long iid);
  164.  
  165.     virtual void constructor(const std::string& directory, bool clearOnInit) = 0;
  166.     virtual Arts::SampleStorageEntry createEntry(const std::string& name) = 0;
  167.     virtual void addEntry(Arts::SampleStorageEntry entry) = 0;
  168.     virtual void removeEntry(Arts::SampleStorageEntry entry) = 0;
  169.     virtual Arts::SampleStorageEntry findEntry(const std::string& name) = 0;
  170. };
  171.  
  172. class ARTS_EXPORT SampleStorage_stub : virtual public SampleStorage_base, virtual public Arts::Object_stub {
  173. protected:
  174.     SampleStorage_stub();
  175.  
  176. public:
  177.     SampleStorage_stub(Arts::Connection *connection, long objectID);
  178.  
  179.     void constructor(const std::string& directory, bool clearOnInit);
  180.     Arts::SampleStorageEntry createEntry(const std::string& name);
  181.     void addEntry(Arts::SampleStorageEntry entry);
  182.     void removeEntry(Arts::SampleStorageEntry entry);
  183.     Arts::SampleStorageEntry findEntry(const std::string& name);
  184. };
  185.  
  186. class ARTS_EXPORT SampleStorage_skel : virtual public SampleStorage_base, virtual public Arts::Object_skel {
  187. public:
  188.     SampleStorage_skel();
  189.  
  190.     static std::string _interfaceNameSkel();
  191.     std::string _interfaceName();
  192.     bool _isCompatibleWith(const std::string& interfacename);
  193.     void _buildMethodTable();
  194.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  195. };
  196.  
  197. }
  198. #include "reference.h"
  199. namespace Arts {
  200. class ARTS_EXPORT SampleStorage : public Arts::Object {
  201. private:
  202.     static Arts::Object_base* _Creator();
  203.     SampleStorage_base *_cache;
  204.     inline SampleStorage_base *_method_call() {
  205.         _pool->checkcreate();
  206.         if(_pool->base) {
  207.             _cache=(SampleStorage_base *)_pool->base->_cast(SampleStorage_base::_IID);
  208.             assert(_cache);
  209.         }
  210.         return _cache;
  211.     }
  212.  
  213. protected:
  214.     inline SampleStorage(SampleStorage_base* b) : Arts::Object(b), _cache(0) {}
  215.  
  216.  
  217. public:
  218.     typedef SampleStorage_base _base_class;
  219.  
  220.     inline SampleStorage() : Arts::Object(_Creator), _cache(0) {}
  221.     inline SampleStorage(const Arts::SubClass& s) :
  222.         Arts::Object(SampleStorage_base::_create(s.string())), _cache(0) {}
  223.     inline SampleStorage(const Arts::Reference &r) :
  224.         Arts::Object(r.isString()?(SampleStorage_base::_fromString(r.string())):(SampleStorage_base::_fromReference(r.reference(),true))), _cache(0) {}
  225.     inline SampleStorage(const Arts::DynamicCast& c) : Arts::Object(SampleStorage_base::_fromDynamicCast(c.object())), _cache(0) {}
  226.     inline SampleStorage(const SampleStorage& target) : Arts::Object(target._pool), _cache(target._cache) {}
  227.     inline SampleStorage(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  228.     inline static SampleStorage null() {return SampleStorage((SampleStorage_base*)0);}
  229.     inline static SampleStorage _from_base(SampleStorage_base* b) {return SampleStorage(b);}
  230.     inline SampleStorage& operator=(const SampleStorage& target) {
  231.         if (_pool == target._pool) return *this;
  232.         _pool->Dec();
  233.         _pool = target._pool;
  234.         _cache = target._cache;
  235.         _pool->Inc();
  236.         return *this;
  237.     }
  238.     inline SampleStorage_base* _base() {return _cache?_cache:_method_call();}
  239.  
  240.     inline SampleStorage(const std::string& directory, bool clearOnInit);
  241.     inline Arts::SampleStorageEntry createEntry(const std::string& name);
  242.     inline void addEntry(Arts::SampleStorageEntry entry);
  243.     inline void removeEntry(Arts::SampleStorageEntry entry);
  244.     inline Arts::SampleStorageEntry findEntry(const std::string& name);
  245. };
  246.  
  247. class ARTS_EXPORT ByteSoundProducer_base : virtual public Arts::SynthModule_base {
  248. public:
  249.     static unsigned long _IID; // interface ID
  250.  
  251.     static ByteSoundProducer_base *_create(const std::string& subClass = "Arts::ByteSoundProducer");
  252.     static ByteSoundProducer_base *_fromString(const std::string& objectref);
  253.     static ByteSoundProducer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  254.  
  255.     static ByteSoundProducer_base *_fromDynamicCast(const Arts::Object& object);
  256.     inline ByteSoundProducer_base *_copy() {
  257.         assert(_refCnt > 0);
  258.         _refCnt++;
  259.         return this;
  260.     }
  261.  
  262.     virtual std::vector<std::string> _defaultPortsIn() const;
  263.     virtual std::vector<std::string> _defaultPortsOut() const;
  264.  
  265.     void *_cast(unsigned long iid);
  266.  
  267.     virtual long samplingRate() = 0;
  268.     virtual long channels() = 0;
  269.     virtual long bits() = 0;
  270. };
  271.  
  272. class ARTS_EXPORT ByteSoundProducer_stub : virtual public ByteSoundProducer_base, virtual public Arts::SynthModule_stub {
  273. protected:
  274.     ByteSoundProducer_stub();
  275.  
  276. public:
  277.     ByteSoundProducer_stub(Arts::Connection *connection, long objectID);
  278.  
  279.     long samplingRate();
  280.     long channels();
  281.     long bits();
  282. };
  283.  
  284. class ARTS_EXPORT ByteSoundProducer_skel : virtual public ByteSoundProducer_base, virtual public Arts::SynthModule_skel {
  285. protected:
  286.     // variables for streams
  287.     Arts::ByteAsyncStream outdata;            // outgoing stream
  288.  
  289.     // handler for asynchronous streams
  290.     virtual void request_outdata(Arts::DataPacket<Arts::mcopbyte> *);
  291.  
  292. protected:
  293.     // emitters for change notifications
  294.     inline void samplingRate_changed(long newValue) {
  295.         _emit_changed("samplingRate_changed",newValue);
  296.     }
  297.     inline void channels_changed(long newValue) {
  298.         _emit_changed("channels_changed",newValue);
  299.     }
  300.     inline void bits_changed(long newValue) {
  301.         _emit_changed("bits_changed",newValue);
  302.     }
  303.  
  304. public:
  305.     ByteSoundProducer_skel();
  306.  
  307.     static std::string _interfaceNameSkel();
  308.     std::string _interfaceName();
  309.     bool _isCompatibleWith(const std::string& interfacename);
  310.     void _buildMethodTable();
  311.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  312.     void notify(const Arts::Notification& notification);
  313. };
  314.  
  315. }
  316. #include "reference.h"
  317. namespace Arts {
  318. class ARTS_EXPORT ByteSoundProducer : public Arts::Object {
  319. private:
  320.     static Arts::Object_base* _Creator();
  321.     ByteSoundProducer_base *_cache;
  322.     inline ByteSoundProducer_base *_method_call() {
  323.         _pool->checkcreate();
  324.         if(_pool->base) {
  325.             _cache=(ByteSoundProducer_base *)_pool->base->_cast(ByteSoundProducer_base::_IID);
  326.             assert(_cache);
  327.         }
  328.         return _cache;
  329.     }
  330.  
  331. protected:
  332.     inline ByteSoundProducer(ByteSoundProducer_base* b) : Arts::Object(b), _cache(0) {}
  333.  
  334.  
  335. public:
  336.     typedef ByteSoundProducer_base _base_class;
  337.  
  338.     inline ByteSoundProducer() : Arts::Object(_Creator), _cache(0) {}
  339.     inline ByteSoundProducer(const Arts::SubClass& s) :
  340.         Arts::Object(ByteSoundProducer_base::_create(s.string())), _cache(0) {}
  341.     inline ByteSoundProducer(const Arts::Reference &r) :
  342.         Arts::Object(r.isString()?(ByteSoundProducer_base::_fromString(r.string())):(ByteSoundProducer_base::_fromReference(r.reference(),true))), _cache(0) {}
  343.     inline ByteSoundProducer(const Arts::DynamicCast& c) : Arts::Object(ByteSoundProducer_base::_fromDynamicCast(c.object())), _cache(0) {}
  344.     inline ByteSoundProducer(const ByteSoundProducer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  345.     inline ByteSoundProducer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  346.     inline static ByteSoundProducer null() {return ByteSoundProducer((ByteSoundProducer_base*)0);}
  347.     inline static ByteSoundProducer _from_base(ByteSoundProducer_base* b) {return ByteSoundProducer(b);}
  348.     inline ByteSoundProducer& operator=(const ByteSoundProducer& target) {
  349.         if (_pool == target._pool) return *this;
  350.         _pool->Dec();
  351.         _pool = target._pool;
  352.         _cache = target._cache;
  353.         _pool->Inc();
  354.         return *this;
  355.     }
  356.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  357.     inline ByteSoundProducer_base* _base() {return _cache?_cache:_method_call();}
  358.  
  359.     inline Arts::AutoSuspendState autoSuspend();
  360.     inline void start();
  361.     inline void stop();
  362.     inline void streamInit();
  363.     inline void streamStart();
  364.     inline void streamEnd();
  365.     inline long samplingRate();
  366.     inline long channels();
  367.     inline long bits();
  368. };
  369.  
  370. class ARTS_EXPORT ByteSoundProducerV2_base : virtual public Arts::ByteSoundProducer_base {
  371. public:
  372.     static unsigned long _IID; // interface ID
  373.  
  374.     static ByteSoundProducerV2_base *_create(const std::string& subClass = "Arts::ByteSoundProducerV2");
  375.     static ByteSoundProducerV2_base *_fromString(const std::string& objectref);
  376.     static ByteSoundProducerV2_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  377.  
  378.     static ByteSoundProducerV2_base *_fromDynamicCast(const Arts::Object& object);
  379.     inline ByteSoundProducerV2_base *_copy() {
  380.         assert(_refCnt > 0);
  381.         _refCnt++;
  382.         return this;
  383.     }
  384.  
  385.     virtual std::vector<std::string> _defaultPortsIn() const;
  386.     virtual std::vector<std::string> _defaultPortsOut() const;
  387.  
  388.     void *_cast(unsigned long iid);
  389.  
  390.     virtual std::string title() = 0;
  391. };
  392.  
  393. class ARTS_EXPORT ByteSoundProducerV2_stub : virtual public ByteSoundProducerV2_base, virtual public Arts::ByteSoundProducer_stub {
  394. protected:
  395.     ByteSoundProducerV2_stub();
  396.  
  397. public:
  398.     ByteSoundProducerV2_stub(Arts::Connection *connection, long objectID);
  399.  
  400.     std::string title();
  401. };
  402.  
  403. class ARTS_EXPORT ByteSoundProducerV2_skel : virtual public ByteSoundProducerV2_base, virtual public Arts::ByteSoundProducer_skel {
  404. protected:
  405.     // emitters for change notifications
  406.     inline void title_changed(const std::string& newValue) {
  407.         _emit_changed("title_changed",newValue);
  408.     }
  409.  
  410. public:
  411.     ByteSoundProducerV2_skel();
  412.  
  413.     static std::string _interfaceNameSkel();
  414.     std::string _interfaceName();
  415.     bool _isCompatibleWith(const std::string& interfacename);
  416.     void _buildMethodTable();
  417.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  418. };
  419.  
  420. }
  421. #include "reference.h"
  422. namespace Arts {
  423. class ARTS_EXPORT ByteSoundProducerV2 : public Arts::Object {
  424. private:
  425.     static Arts::Object_base* _Creator();
  426.     ByteSoundProducerV2_base *_cache;
  427.     inline ByteSoundProducerV2_base *_method_call() {
  428.         _pool->checkcreate();
  429.         if(_pool->base) {
  430.             _cache=(ByteSoundProducerV2_base *)_pool->base->_cast(ByteSoundProducerV2_base::_IID);
  431.             assert(_cache);
  432.         }
  433.         return _cache;
  434.     }
  435.  
  436. protected:
  437.     inline ByteSoundProducerV2(ByteSoundProducerV2_base* b) : Arts::Object(b), _cache(0) {}
  438.  
  439.  
  440. public:
  441.     typedef ByteSoundProducerV2_base _base_class;
  442.  
  443.     inline ByteSoundProducerV2() : Arts::Object(_Creator), _cache(0) {}
  444.     inline ByteSoundProducerV2(const Arts::SubClass& s) :
  445.         Arts::Object(ByteSoundProducerV2_base::_create(s.string())), _cache(0) {}
  446.     inline ByteSoundProducerV2(const Arts::Reference &r) :
  447.         Arts::Object(r.isString()?(ByteSoundProducerV2_base::_fromString(r.string())):(ByteSoundProducerV2_base::_fromReference(r.reference(),true))), _cache(0) {}
  448.     inline ByteSoundProducerV2(const Arts::DynamicCast& c) : Arts::Object(ByteSoundProducerV2_base::_fromDynamicCast(c.object())), _cache(0) {}
  449.     inline ByteSoundProducerV2(const ByteSoundProducerV2& target) : Arts::Object(target._pool), _cache(target._cache) {}
  450.     inline ByteSoundProducerV2(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  451.     inline static ByteSoundProducerV2 null() {return ByteSoundProducerV2((ByteSoundProducerV2_base*)0);}
  452.     inline static ByteSoundProducerV2 _from_base(ByteSoundProducerV2_base* b) {return ByteSoundProducerV2(b);}
  453.     inline ByteSoundProducerV2& operator=(const ByteSoundProducerV2& target) {
  454.         if (_pool == target._pool) return *this;
  455.         _pool->Dec();
  456.         _pool = target._pool;
  457.         _cache = target._cache;
  458.         _pool->Inc();
  459.         return *this;
  460.     }
  461.     inline operator Arts::ByteSoundProducer() const { return Arts::ByteSoundProducer(*_pool); }
  462.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  463.     inline ByteSoundProducerV2_base* _base() {return _cache?_cache:_method_call();}
  464.  
  465.     inline long samplingRate();
  466.     inline long channels();
  467.     inline long bits();
  468.     inline Arts::AutoSuspendState autoSuspend();
  469.     inline void start();
  470.     inline void stop();
  471.     inline void streamInit();
  472.     inline void streamStart();
  473.     inline void streamEnd();
  474.     inline std::string title();
  475. };
  476.  
  477. class ARTS_EXPORT ByteSoundReceiver_base : virtual public Arts::SynthModule_base {
  478. public:
  479.     static unsigned long _IID; // interface ID
  480.  
  481.     static ByteSoundReceiver_base *_create(const std::string& subClass = "Arts::ByteSoundReceiver");
  482.     static ByteSoundReceiver_base *_fromString(const std::string& objectref);
  483.     static ByteSoundReceiver_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  484.  
  485.     static ByteSoundReceiver_base *_fromDynamicCast(const Arts::Object& object);
  486.     inline ByteSoundReceiver_base *_copy() {
  487.         assert(_refCnt > 0);
  488.         _refCnt++;
  489.         return this;
  490.     }
  491.  
  492.     virtual std::vector<std::string> _defaultPortsIn() const;
  493.     virtual std::vector<std::string> _defaultPortsOut() const;
  494.  
  495.     void *_cast(unsigned long iid);
  496.  
  497.     virtual long samplingRate() = 0;
  498.     virtual long channels() = 0;
  499.     virtual long bits() = 0;
  500.     virtual std::string title() = 0;
  501. };
  502.  
  503. class ARTS_EXPORT ByteSoundReceiver_stub : virtual public ByteSoundReceiver_base, virtual public Arts::SynthModule_stub {
  504. protected:
  505.     ByteSoundReceiver_stub();
  506.  
  507. public:
  508.     ByteSoundReceiver_stub(Arts::Connection *connection, long objectID);
  509.  
  510.     long samplingRate();
  511.     long channels();
  512.     long bits();
  513.     std::string title();
  514. };
  515.  
  516. class ARTS_EXPORT ByteSoundReceiver_skel : virtual public ByteSoundReceiver_base, virtual public Arts::SynthModule_skel {
  517. protected:
  518.     // variables for streams
  519.     Arts::ByteAsyncStream indata;             // incoming stream
  520.  
  521.     // handler for asynchronous streams
  522.     virtual void process_indata(Arts::DataPacket<Arts::mcopbyte> *) = 0;
  523.  
  524. protected:
  525.     // emitters for change notifications
  526.     inline void samplingRate_changed(long newValue) {
  527.         _emit_changed("samplingRate_changed",newValue);
  528.     }
  529.     inline void channels_changed(long newValue) {
  530.         _emit_changed("channels_changed",newValue);
  531.     }
  532.     inline void bits_changed(long newValue) {
  533.         _emit_changed("bits_changed",newValue);
  534.     }
  535.     inline void title_changed(const std::string& newValue) {
  536.         _emit_changed("title_changed",newValue);
  537.     }
  538.  
  539. public:
  540.     ByteSoundReceiver_skel();
  541.  
  542.     static std::string _interfaceNameSkel();
  543.     std::string _interfaceName();
  544.     bool _isCompatibleWith(const std::string& interfacename);
  545.     void _buildMethodTable();
  546.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  547.     void notify(const Arts::Notification& notification);
  548. };
  549.  
  550. }
  551. #include "reference.h"
  552. namespace Arts {
  553. class ARTS_EXPORT ByteSoundReceiver : public Arts::Object {
  554. private:
  555.     static Arts::Object_base* _Creator();
  556.     ByteSoundReceiver_base *_cache;
  557.     inline ByteSoundReceiver_base *_method_call() {
  558.         _pool->checkcreate();
  559.         if(_pool->base) {
  560.             _cache=(ByteSoundReceiver_base *)_pool->base->_cast(ByteSoundReceiver_base::_IID);
  561.             assert(_cache);
  562.         }
  563.         return _cache;
  564.     }
  565.  
  566. protected:
  567.     inline ByteSoundReceiver(ByteSoundReceiver_base* b) : Arts::Object(b), _cache(0) {}
  568.  
  569.  
  570. public:
  571.     typedef ByteSoundReceiver_base _base_class;
  572.  
  573.     inline ByteSoundReceiver() : Arts::Object(_Creator), _cache(0) {}
  574.     inline ByteSoundReceiver(const Arts::SubClass& s) :
  575.         Arts::Object(ByteSoundReceiver_base::_create(s.string())), _cache(0) {}
  576.     inline ByteSoundReceiver(const Arts::Reference &r) :
  577.         Arts::Object(r.isString()?(ByteSoundReceiver_base::_fromString(r.string())):(ByteSoundReceiver_base::_fromReference(r.reference(),true))), _cache(0) {}
  578.     inline ByteSoundReceiver(const Arts::DynamicCast& c) : Arts::Object(ByteSoundReceiver_base::_fromDynamicCast(c.object())), _cache(0) {}
  579.     inline ByteSoundReceiver(const ByteSoundReceiver& target) : Arts::Object(target._pool), _cache(target._cache) {}
  580.     inline ByteSoundReceiver(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  581.     inline static ByteSoundReceiver null() {return ByteSoundReceiver((ByteSoundReceiver_base*)0);}
  582.     inline static ByteSoundReceiver _from_base(ByteSoundReceiver_base* b) {return ByteSoundReceiver(b);}
  583.     inline ByteSoundReceiver& operator=(const ByteSoundReceiver& target) {
  584.         if (_pool == target._pool) return *this;
  585.         _pool->Dec();
  586.         _pool = target._pool;
  587.         _cache = target._cache;
  588.         _pool->Inc();
  589.         return *this;
  590.     }
  591.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  592.     inline ByteSoundReceiver_base* _base() {return _cache?_cache:_method_call();}
  593.  
  594.     inline Arts::AutoSuspendState autoSuspend();
  595.     inline void start();
  596.     inline void stop();
  597.     inline void streamInit();
  598.     inline void streamStart();
  599.     inline void streamEnd();
  600.     inline long samplingRate();
  601.     inline long channels();
  602.     inline long bits();
  603.     inline std::string title();
  604. };
  605.  
  606. class ARTS_EXPORT SimpleSoundServer_base : virtual public Arts::PlayObjectFactory_base {
  607. public:
  608.     static unsigned long _IID; // interface ID
  609.  
  610.     static SimpleSoundServer_base *_create(const std::string& subClass = "Arts::SimpleSoundServer");
  611.     static SimpleSoundServer_base *_fromString(const std::string& objectref);
  612.     static SimpleSoundServer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  613.  
  614.     static SimpleSoundServer_base *_fromDynamicCast(const Arts::Object& object);
  615.     inline SimpleSoundServer_base *_copy() {
  616.         assert(_refCnt > 0);
  617.         _refCnt++;
  618.         return this;
  619.     }
  620.  
  621.     virtual std::vector<std::string> _defaultPortsIn() const;
  622.     virtual std::vector<std::string> _defaultPortsOut() const;
  623.  
  624.     void *_cast(unsigned long iid);
  625.  
  626.     virtual Arts::StereoEffectStack outstack() = 0;
  627.     virtual float minStreamBufferTime() = 0;
  628.     virtual float serverBufferTime() = 0;
  629.     virtual long play(const std::string& filename) = 0;
  630.     virtual void attach(Arts::ByteSoundProducer producer) = 0;
  631.     virtual void detach(Arts::ByteSoundProducer producer) = 0;
  632.     virtual void attachRecorder(Arts::ByteSoundReceiver receiver) = 0;
  633.     virtual void detachRecorder(Arts::ByteSoundReceiver receiver) = 0;
  634.     virtual Arts::Object createObject(const std::string& name) = 0;
  635. };
  636.  
  637. class ARTS_EXPORT SimpleSoundServer_stub : virtual public SimpleSoundServer_base, virtual public Arts::PlayObjectFactory_stub {
  638. protected:
  639.     SimpleSoundServer_stub();
  640.  
  641. public:
  642.     SimpleSoundServer_stub(Arts::Connection *connection, long objectID);
  643.  
  644.     Arts::StereoEffectStack outstack();
  645.     float minStreamBufferTime();
  646.     float serverBufferTime();
  647.     long play(const std::string& filename);
  648.     void attach(Arts::ByteSoundProducer producer);
  649.     void detach(Arts::ByteSoundProducer producer);
  650.     void attachRecorder(Arts::ByteSoundReceiver receiver);
  651.     void detachRecorder(Arts::ByteSoundReceiver receiver);
  652.     Arts::Object createObject(const std::string& name);
  653. };
  654.  
  655. class ARTS_EXPORT SimpleSoundServer_skel : virtual public SimpleSoundServer_base, virtual public Arts::PlayObjectFactory_skel {
  656. protected:
  657.     // emitters for change notifications
  658.     inline void minStreamBufferTime_changed(float newValue) {
  659.         _emit_changed("minStreamBufferTime_changed",newValue);
  660.     }
  661.     inline void serverBufferTime_changed(float newValue) {
  662.         _emit_changed("serverBufferTime_changed",newValue);
  663.     }
  664.  
  665. public:
  666.     SimpleSoundServer_skel();
  667.  
  668.     static std::string _interfaceNameSkel();
  669.     std::string _interfaceName();
  670.     bool _isCompatibleWith(const std::string& interfacename);
  671.     void _buildMethodTable();
  672.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  673. };
  674.  
  675. }
  676. #include "reference.h"
  677. namespace Arts {
  678. class ARTS_EXPORT SimpleSoundServer : public Arts::Object {
  679. private:
  680.     static Arts::Object_base* _Creator();
  681.     SimpleSoundServer_base *_cache;
  682.     inline SimpleSoundServer_base *_method_call() {
  683.         _pool->checkcreate();
  684.         if(_pool->base) {
  685.             _cache=(SimpleSoundServer_base *)_pool->base->_cast(SimpleSoundServer_base::_IID);
  686.             assert(_cache);
  687.         }
  688.         return _cache;
  689.     }
  690.  
  691. protected:
  692.     inline SimpleSoundServer(SimpleSoundServer_base* b) : Arts::Object(b), _cache(0) {}
  693.  
  694.  
  695. public:
  696.     typedef SimpleSoundServer_base _base_class;
  697.  
  698.     inline SimpleSoundServer() : Arts::Object(_Creator), _cache(0) {}
  699.     inline SimpleSoundServer(const Arts::SubClass& s) :
  700.         Arts::Object(SimpleSoundServer_base::_create(s.string())), _cache(0) {}
  701.     inline SimpleSoundServer(const Arts::Reference &r) :
  702.         Arts::Object(r.isString()?(SimpleSoundServer_base::_fromString(r.string())):(SimpleSoundServer_base::_fromReference(r.reference(),true))), _cache(0) {}
  703.     inline SimpleSoundServer(const Arts::DynamicCast& c) : Arts::Object(SimpleSoundServer_base::_fromDynamicCast(c.object())), _cache(0) {}
  704.     inline SimpleSoundServer(const SimpleSoundServer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  705.     inline SimpleSoundServer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  706.     inline static SimpleSoundServer null() {return SimpleSoundServer((SimpleSoundServer_base*)0);}
  707.     inline static SimpleSoundServer _from_base(SimpleSoundServer_base* b) {return SimpleSoundServer(b);}
  708.     inline SimpleSoundServer& operator=(const SimpleSoundServer& target) {
  709.         if (_pool == target._pool) return *this;
  710.         _pool->Dec();
  711.         _pool = target._pool;
  712.         _cache = target._cache;
  713.         _pool->Inc();
  714.         return *this;
  715.     }
  716.     inline operator Arts::PlayObjectFactory() const { return Arts::PlayObjectFactory(*_pool); }
  717.     inline SimpleSoundServer_base* _base() {return _cache?_cache:_method_call();}
  718.  
  719.     inline Arts::PlayObject createPlayObject(const std::string& filename);
  720.     inline Arts::StereoEffectStack outstack();
  721.     inline float minStreamBufferTime();
  722.     inline float serverBufferTime();
  723.     inline long play(const std::string& filename);
  724.     inline void attach(Arts::ByteSoundProducer producer);
  725.     inline void detach(Arts::ByteSoundProducer producer);
  726.     inline void attachRecorder(Arts::ByteSoundReceiver receiver);
  727.     inline void detachRecorder(Arts::ByteSoundReceiver receiver);
  728.     inline Arts::Object createObject(const std::string& name);
  729. };
  730.  
  731. class ARTS_EXPORT SoundServer_base : virtual public Arts::SimpleSoundServer_base {
  732. public:
  733.     static unsigned long _IID; // interface ID
  734.  
  735.     static SoundServer_base *_create(const std::string& subClass = "Arts::SoundServer");
  736.     static SoundServer_base *_fromString(const std::string& objectref);
  737.     static SoundServer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  738.  
  739.     static SoundServer_base *_fromDynamicCast(const Arts::Object& object);
  740.     inline SoundServer_base *_copy() {
  741.         assert(_refCnt > 0);
  742.         _refCnt++;
  743.         return this;
  744.     }
  745.  
  746.     virtual std::vector<std::string> _defaultPortsIn() const;
  747.     virtual std::vector<std::string> _defaultPortsOut() const;
  748.  
  749.     void *_cast(unsigned long iid);
  750.  
  751.     virtual Arts::RealtimeStatus realtimeStatus() = 0;
  752.     virtual long secondsUntilSuspend() = 0;
  753.     virtual bool suspend() = 0;
  754.     virtual bool suspended() = 0;
  755.     virtual bool terminate() = 0;
  756. };
  757.  
  758. class ARTS_EXPORT SoundServer_stub : virtual public SoundServer_base, virtual public Arts::SimpleSoundServer_stub {
  759. protected:
  760.     SoundServer_stub();
  761.  
  762. public:
  763.     SoundServer_stub(Arts::Connection *connection, long objectID);
  764.  
  765.     Arts::RealtimeStatus realtimeStatus();
  766.     long secondsUntilSuspend();
  767.     bool suspend();
  768.     bool suspended();
  769.     bool terminate();
  770. };
  771.  
  772. class ARTS_EXPORT SoundServer_skel : virtual public SoundServer_base, virtual public Arts::SimpleSoundServer_skel {
  773. protected:
  774.     // emitters for change notifications
  775.     inline void realtimeStatus_changed(Arts::RealtimeStatus newValue) {
  776.         _emit_changed("realtimeStatus_changed",newValue);
  777.     }
  778.     inline void secondsUntilSuspend_changed(long newValue) {
  779.         _emit_changed("secondsUntilSuspend_changed",newValue);
  780.     }
  781.  
  782. public:
  783.     SoundServer_skel();
  784.  
  785.     static std::string _interfaceNameSkel();
  786.     std::string _interfaceName();
  787.     bool _isCompatibleWith(const std::string& interfacename);
  788.     void _buildMethodTable();
  789.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  790. };
  791.  
  792. }
  793. #include "reference.h"
  794. namespace Arts {
  795. class ARTS_EXPORT SoundServer : public Arts::Object {
  796. private:
  797.     static Arts::Object_base* _Creator();
  798.     SoundServer_base *_cache;
  799.     inline SoundServer_base *_method_call() {
  800.         _pool->checkcreate();
  801.         if(_pool->base) {
  802.             _cache=(SoundServer_base *)_pool->base->_cast(SoundServer_base::_IID);
  803.             assert(_cache);
  804.         }
  805.         return _cache;
  806.     }
  807.  
  808. protected:
  809.     inline SoundServer(SoundServer_base* b) : Arts::Object(b), _cache(0) {}
  810.  
  811.  
  812. public:
  813.     typedef SoundServer_base _base_class;
  814.  
  815.     inline SoundServer() : Arts::Object(_Creator), _cache(0) {}
  816.     inline SoundServer(const Arts::SubClass& s) :
  817.         Arts::Object(SoundServer_base::_create(s.string())), _cache(0) {}
  818.     inline SoundServer(const Arts::Reference &r) :
  819.         Arts::Object(r.isString()?(SoundServer_base::_fromString(r.string())):(SoundServer_base::_fromReference(r.reference(),true))), _cache(0) {}
  820.     inline SoundServer(const Arts::DynamicCast& c) : Arts::Object(SoundServer_base::_fromDynamicCast(c.object())), _cache(0) {}
  821.     inline SoundServer(const SoundServer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  822.     inline SoundServer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  823.     inline static SoundServer null() {return SoundServer((SoundServer_base*)0);}
  824.     inline static SoundServer _from_base(SoundServer_base* b) {return SoundServer(b);}
  825.     inline SoundServer& operator=(const SoundServer& target) {
  826.         if (_pool == target._pool) return *this;
  827.         _pool->Dec();
  828.         _pool = target._pool;
  829.         _cache = target._cache;
  830.         _pool->Inc();
  831.         return *this;
  832.     }
  833.     inline operator Arts::SimpleSoundServer() const { return Arts::SimpleSoundServer(*_pool); }
  834.     inline operator Arts::PlayObjectFactory() const { return Arts::PlayObjectFactory(*_pool); }
  835.     inline SoundServer_base* _base() {return _cache?_cache:_method_call();}
  836.  
  837.     inline Arts::StereoEffectStack outstack();
  838.     inline float minStreamBufferTime();
  839.     inline float serverBufferTime();
  840.     inline long play(const std::string& filename);
  841.     inline void attach(Arts::ByteSoundProducer producer);
  842.     inline void detach(Arts::ByteSoundProducer producer);
  843.     inline void attachRecorder(Arts::ByteSoundReceiver receiver);
  844.     inline void detachRecorder(Arts::ByteSoundReceiver receiver);
  845.     inline Arts::Object createObject(const std::string& name);
  846.     inline Arts::PlayObject createPlayObject(const std::string& filename);
  847.     inline Arts::RealtimeStatus realtimeStatus();
  848.     inline long secondsUntilSuspend();
  849.     inline bool suspend();
  850.     inline bool suspended();
  851.     inline bool terminate();
  852. };
  853.  
  854. class ARTS_EXPORT SoundServerV2_base : virtual public Arts::SoundServer_base,
  855.     virtual public Arts::PlayObjectFactoryV2_base {
  856. public:
  857.     static unsigned long _IID; // interface ID
  858.  
  859.     static SoundServerV2_base *_create(const std::string& subClass = "Arts::SoundServerV2");
  860.     static SoundServerV2_base *_fromString(const std::string& objectref);
  861.     static SoundServerV2_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  862.  
  863.     static SoundServerV2_base *_fromDynamicCast(const Arts::Object& object);
  864.     inline SoundServerV2_base *_copy() {
  865.         assert(_refCnt > 0);
  866.         _refCnt++;
  867.         return this;
  868.     }
  869.  
  870.     virtual std::vector<std::string> _defaultPortsIn() const;
  871.     virtual std::vector<std::string> _defaultPortsOut() const;
  872.  
  873.     void *_cast(unsigned long iid);
  874.  
  875.     virtual long autoSuspendSeconds() = 0;
  876.     virtual void autoSuspendSeconds(long newValue) = 0;
  877.     virtual long bufferSizeMultiplier() = 0;
  878.     virtual void bufferSizeMultiplier(long newValue) = 0;
  879.     virtual float cpuUsage() = 0;
  880.     virtual std::string audioMethod() = 0;
  881.     virtual long samplingRate() = 0;
  882.     virtual long channels() = 0;
  883.     virtual long bits() = 0;
  884.     virtual bool fullDuplex() = 0;
  885.     virtual std::string audioDevice() = 0;
  886.     virtual long fragments() = 0;
  887.     virtual long fragmentSize() = 0;
  888.     virtual std::string version() = 0;
  889.     virtual Arts::StereoVolumeControl outVolume() = 0;
  890.     virtual Arts::SampleStorage sampleStorage() = 0;
  891.     virtual void checkNewObjects() = 0;
  892. };
  893.  
  894. class ARTS_EXPORT SoundServerV2_stub : virtual public SoundServerV2_base, virtual public Arts::SoundServer_stub,
  895.     virtual public Arts::PlayObjectFactoryV2_stub {
  896. protected:
  897.     SoundServerV2_stub();
  898.  
  899. public:
  900.     SoundServerV2_stub(Arts::Connection *connection, long objectID);
  901.  
  902.     long autoSuspendSeconds();
  903.     void autoSuspendSeconds(long newValue);
  904.     long bufferSizeMultiplier();
  905.     void bufferSizeMultiplier(long newValue);
  906.     float cpuUsage();
  907.     std::string audioMethod();
  908.     long samplingRate();
  909.     long channels();
  910.     long bits();
  911.     bool fullDuplex();
  912.     std::string audioDevice();
  913.     long fragments();
  914.     long fragmentSize();
  915.     std::string version();
  916.     Arts::StereoVolumeControl outVolume();
  917.     Arts::SampleStorage sampleStorage();
  918.     void checkNewObjects();
  919. };
  920.  
  921. class ARTS_EXPORT SoundServerV2_skel : virtual public SoundServerV2_base, virtual public Arts::SoundServer_skel,
  922.     virtual public Arts::PlayObjectFactoryV2_skel {
  923. protected:
  924.     // emitters for change notifications
  925.     inline void autoSuspendSeconds_changed(long newValue) {
  926.         _emit_changed("autoSuspendSeconds_changed",newValue);
  927.     }
  928.     inline void bufferSizeMultiplier_changed(long newValue) {
  929.         _emit_changed("bufferSizeMultiplier_changed",newValue);
  930.     }
  931.     inline void cpuUsage_changed(float newValue) {
  932.         _emit_changed("cpuUsage_changed",newValue);
  933.     }
  934.     inline void audioMethod_changed(const std::string& newValue) {
  935.         _emit_changed("audioMethod_changed",newValue);
  936.     }
  937.     inline void samplingRate_changed(long newValue) {
  938.         _emit_changed("samplingRate_changed",newValue);
  939.     }
  940.     inline void channels_changed(long newValue) {
  941.         _emit_changed("channels_changed",newValue);
  942.     }
  943.     inline void bits_changed(long newValue) {
  944.         _emit_changed("bits_changed",newValue);
  945.     }
  946.     inline void fullDuplex_changed(bool newValue) {
  947.         _emit_changed("fullDuplex_changed",newValue);
  948.     }
  949.     inline void audioDevice_changed(const std::string& newValue) {
  950.         _emit_changed("audioDevice_changed",newValue);
  951.     }
  952.     inline void fragments_changed(long newValue) {
  953.         _emit_changed("fragments_changed",newValue);
  954.     }
  955.     inline void fragmentSize_changed(long newValue) {
  956.         _emit_changed("fragmentSize_changed",newValue);
  957.     }
  958.     inline void version_changed(const std::string& newValue) {
  959.         _emit_changed("version_changed",newValue);
  960.     }
  961.  
  962. public:
  963.     SoundServerV2_skel();
  964.  
  965.     static std::string _interfaceNameSkel();
  966.     std::string _interfaceName();
  967.     bool _isCompatibleWith(const std::string& interfacename);
  968.     void _buildMethodTable();
  969.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  970. };
  971.  
  972. }
  973. #include "reference.h"
  974. namespace Arts {
  975. class ARTS_EXPORT SoundServerV2 : public Arts::Object {
  976. private:
  977.     static Arts::Object_base* _Creator();
  978.     SoundServerV2_base *_cache;
  979.     inline SoundServerV2_base *_method_call() {
  980.         _pool->checkcreate();
  981.         if(_pool->base) {
  982.             _cache=(SoundServerV2_base *)_pool->base->_cast(SoundServerV2_base::_IID);
  983.             assert(_cache);
  984.         }
  985.         return _cache;
  986.     }
  987.  
  988. protected:
  989.     inline SoundServerV2(SoundServerV2_base* b) : Arts::Object(b), _cache(0) {}
  990.  
  991.  
  992. public:
  993.     typedef SoundServerV2_base _base_class;
  994.  
  995.     inline SoundServerV2() : Arts::Object(_Creator), _cache(0) {}
  996.     inline SoundServerV2(const Arts::SubClass& s) :
  997.         Arts::Object(SoundServerV2_base::_create(s.string())), _cache(0) {}
  998.     inline SoundServerV2(const Arts::Reference &r) :
  999.         Arts::Object(r.isString()?(SoundServerV2_base::_fromString(r.string())):(SoundServerV2_base::_fromReference(r.reference(),true))), _cache(0) {}
  1000.     inline SoundServerV2(const Arts::DynamicCast& c) : Arts::Object(SoundServerV2_base::_fromDynamicCast(c.object())), _cache(0) {}
  1001.     inline SoundServerV2(const SoundServerV2& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1002.     inline SoundServerV2(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1003.     inline static SoundServerV2 null() {return SoundServerV2((SoundServerV2_base*)0);}
  1004.     inline static SoundServerV2 _from_base(SoundServerV2_base* b) {return SoundServerV2(b);}
  1005.     inline SoundServerV2& operator=(const SoundServerV2& target) {
  1006.         if (_pool == target._pool) return *this;
  1007.         _pool->Dec();
  1008.         _pool = target._pool;
  1009.         _cache = target._cache;
  1010.         _pool->Inc();
  1011.         return *this;
  1012.     }
  1013.     inline operator Arts::SoundServer() const { return Arts::SoundServer(*_pool); }
  1014.     inline operator Arts::SimpleSoundServer() const { return Arts::SimpleSoundServer(*_pool); }
  1015.     inline operator Arts::PlayObjectFactory() const { return Arts::PlayObjectFactory(*_pool); }
  1016.     inline operator Arts::PlayObjectFactoryV2() const { return Arts::PlayObjectFactoryV2(*_pool); }
  1017.     inline SoundServerV2_base* _base() {return _cache?_cache:_method_call();}
  1018.  
  1019.     inline Arts::RealtimeStatus realtimeStatus();
  1020.     inline long secondsUntilSuspend();
  1021.     inline bool suspend();
  1022.     inline bool suspended();
  1023.     inline bool terminate();
  1024.     inline Arts::StereoEffectStack outstack();
  1025.     inline float minStreamBufferTime();
  1026.     inline float serverBufferTime();
  1027.     inline long play(const std::string& filename);
  1028.     inline void attach(Arts::ByteSoundProducer producer);
  1029.     inline void detach(Arts::ByteSoundProducer producer);
  1030.     inline void attachRecorder(Arts::ByteSoundReceiver receiver);
  1031.     inline void detachRecorder(Arts::ByteSoundReceiver receiver);
  1032.     inline Arts::Object createObject(const std::string& name);
  1033.     inline Arts::PlayObject createPlayObject(const std::string& filename);
  1034.     inline Arts::PlayObject createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS);
  1035.     inline Arts::PlayObject createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS);
  1036.     inline long autoSuspendSeconds();
  1037.     inline void autoSuspendSeconds(long _newValue);
  1038.     inline long bufferSizeMultiplier();
  1039.     inline void bufferSizeMultiplier(long _newValue);
  1040.     inline float cpuUsage();
  1041.     inline std::string audioMethod();
  1042.     inline long samplingRate();
  1043.     inline long channels();
  1044.     inline long bits();
  1045.     inline bool fullDuplex();
  1046.     inline std::string audioDevice();
  1047.     inline long fragments();
  1048.     inline long fragmentSize();
  1049.     inline std::string version();
  1050.     inline Arts::StereoVolumeControl outVolume();
  1051.     inline Arts::SampleStorage sampleStorage();
  1052.     inline void checkNewObjects();
  1053. };
  1054.  
  1055. class ARTS_EXPORT WavPlayObject_base : virtual public Arts::PlayObject_base,
  1056.     virtual public Arts::SynthModule_base {
  1057. public:
  1058.     static unsigned long _IID; // interface ID
  1059.  
  1060.     static WavPlayObject_base *_create(const std::string& subClass = "Arts::WavPlayObject");
  1061.     static WavPlayObject_base *_fromString(const std::string& objectref);
  1062.     static WavPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1063.  
  1064.     static WavPlayObject_base *_fromDynamicCast(const Arts::Object& object);
  1065.     inline WavPlayObject_base *_copy() {
  1066.         assert(_refCnt > 0);
  1067.         _refCnt++;
  1068.         return this;
  1069.     }
  1070.  
  1071.     virtual std::vector<std::string> _defaultPortsIn() const;
  1072.     virtual std::vector<std::string> _defaultPortsOut() const;
  1073.  
  1074.     void *_cast(unsigned long iid);
  1075.  
  1076. };
  1077.  
  1078. class ARTS_EXPORT WavPlayObject_stub : virtual public WavPlayObject_base, virtual public Arts::PlayObject_stub,
  1079.     virtual public Arts::SynthModule_stub {
  1080. protected:
  1081.     WavPlayObject_stub();
  1082.  
  1083. public:
  1084.     WavPlayObject_stub(Arts::Connection *connection, long objectID);
  1085.  
  1086. };
  1087.  
  1088. class ARTS_EXPORT WavPlayObject_skel : virtual public WavPlayObject_base, virtual public Arts::PlayObject_skel,
  1089.     virtual public Arts::SynthModule_skel {
  1090. protected:
  1091.     // variables for streams
  1092.     float *left;                              // outgoing stream
  1093.     float *right;                             // outgoing stream
  1094.  
  1095. public:
  1096.     WavPlayObject_skel();
  1097.  
  1098.     static std::string _interfaceNameSkel();
  1099.     std::string _interfaceName();
  1100.     bool _isCompatibleWith(const std::string& interfacename);
  1101.     void _buildMethodTable();
  1102.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1103. };
  1104.  
  1105. }
  1106. #include "reference.h"
  1107. namespace Arts {
  1108. class ARTS_EXPORT WavPlayObject : public Arts::Object {
  1109. private:
  1110.     static Arts::Object_base* _Creator();
  1111.     WavPlayObject_base *_cache;
  1112.     inline WavPlayObject_base *_method_call() {
  1113.         _pool->checkcreate();
  1114.         if(_pool->base) {
  1115.             _cache=(WavPlayObject_base *)_pool->base->_cast(WavPlayObject_base::_IID);
  1116.             assert(_cache);
  1117.         }
  1118.         return _cache;
  1119.     }
  1120.  
  1121. protected:
  1122.     inline WavPlayObject(WavPlayObject_base* b) : Arts::Object(b), _cache(0) {}
  1123.  
  1124.  
  1125. public:
  1126.     typedef WavPlayObject_base _base_class;
  1127.  
  1128.     inline WavPlayObject() : Arts::Object(_Creator), _cache(0) {}
  1129.     inline WavPlayObject(const Arts::SubClass& s) :
  1130.         Arts::Object(WavPlayObject_base::_create(s.string())), _cache(0) {}
  1131.     inline WavPlayObject(const Arts::Reference &r) :
  1132.         Arts::Object(r.isString()?(WavPlayObject_base::_fromString(r.string())):(WavPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  1133.     inline WavPlayObject(const Arts::DynamicCast& c) : Arts::Object(WavPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  1134.     inline WavPlayObject(const WavPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1135.     inline WavPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1136.     inline static WavPlayObject null() {return WavPlayObject((WavPlayObject_base*)0);}
  1137.     inline static WavPlayObject _from_base(WavPlayObject_base* b) {return WavPlayObject(b);}
  1138.     inline WavPlayObject& operator=(const WavPlayObject& target) {
  1139.         if (_pool == target._pool) return *this;
  1140.         _pool->Dec();
  1141.         _pool = target._pool;
  1142.         _cache = target._cache;
  1143.         _pool->Inc();
  1144.         return *this;
  1145.     }
  1146.     inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
  1147.     inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
  1148.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1149.     inline WavPlayObject_base* _base() {return _cache?_cache:_method_call();}
  1150.  
  1151.     inline std::string description();
  1152.     inline Arts::poTime currentTime();
  1153.     inline Arts::poTime overallTime();
  1154.     inline Arts::poCapabilities capabilities();
  1155.     inline std::string mediaName();
  1156.     inline Arts::poState state();
  1157.     inline void play();
  1158.     inline void seek(const Arts::poTime& newTime);
  1159.     inline void pause();
  1160.     inline void halt();
  1161.     inline bool loadMedia(const std::string& filename);
  1162.     inline Arts::AutoSuspendState autoSuspend();
  1163.     inline void start();
  1164.     inline void stop();
  1165.     inline void streamInit();
  1166.     inline void streamStart();
  1167.     inline void streamEnd();
  1168. };
  1169.  
  1170. class ARTS_EXPORT GSLPlayObject_base : virtual public Arts::PlayObject_base,
  1171.     virtual public Arts::PitchablePlayObject_base,
  1172.     virtual public Arts::SynthModule_base {
  1173. public:
  1174.     static unsigned long _IID; // interface ID
  1175.  
  1176.     static GSLPlayObject_base *_create(const std::string& subClass = "Arts::GSLPlayObject");
  1177.     static GSLPlayObject_base *_fromString(const std::string& objectref);
  1178.     static GSLPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1179.  
  1180.     static GSLPlayObject_base *_fromDynamicCast(const Arts::Object& object);
  1181.     inline GSLPlayObject_base *_copy() {
  1182.         assert(_refCnt > 0);
  1183.         _refCnt++;
  1184.         return this;
  1185.     }
  1186.  
  1187.     virtual std::vector<std::string> _defaultPortsIn() const;
  1188.     virtual std::vector<std::string> _defaultPortsOut() const;
  1189.  
  1190.     void *_cast(unsigned long iid);
  1191.  
  1192.     virtual bool done() = 0;
  1193.     virtual void done(bool newValue) = 0;
  1194. };
  1195.  
  1196. class ARTS_EXPORT GSLPlayObject_stub : virtual public GSLPlayObject_base, virtual public Arts::PlayObject_stub,
  1197.     virtual public Arts::PitchablePlayObject_stub,
  1198.     virtual public Arts::SynthModule_stub {
  1199. protected:
  1200.     GSLPlayObject_stub();
  1201.  
  1202. public:
  1203.     GSLPlayObject_stub(Arts::Connection *connection, long objectID);
  1204.  
  1205.     bool done();
  1206.     void done(bool newValue);
  1207. };
  1208.  
  1209. class ARTS_EXPORT GSLPlayObject_skel : virtual public GSLPlayObject_base, virtual public Arts::PlayObject_skel,
  1210.     virtual public Arts::PitchablePlayObject_skel,
  1211.     virtual public Arts::SynthModule_skel {
  1212. protected:
  1213.     // variables for streams
  1214.     float *left;                              // outgoing stream
  1215.     float *right;                             // outgoing stream
  1216.  
  1217. protected:
  1218.     // emitters for change notifications
  1219.     inline void done_changed(bool newValue) {
  1220.         _emit_changed("done_changed",newValue);
  1221.     }
  1222.  
  1223. public:
  1224.     GSLPlayObject_skel();
  1225.  
  1226.     static std::string _interfaceNameSkel();
  1227.     std::string _interfaceName();
  1228.     bool _isCompatibleWith(const std::string& interfacename);
  1229.     void _buildMethodTable();
  1230.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1231. };
  1232.  
  1233. }
  1234. #include "reference.h"
  1235. namespace Arts {
  1236. class ARTS_EXPORT GSLPlayObject : public Arts::Object {
  1237. private:
  1238.     static Arts::Object_base* _Creator();
  1239.     GSLPlayObject_base *_cache;
  1240.     inline GSLPlayObject_base *_method_call() {
  1241.         _pool->checkcreate();
  1242.         if(_pool->base) {
  1243.             _cache=(GSLPlayObject_base *)_pool->base->_cast(GSLPlayObject_base::_IID);
  1244.             assert(_cache);
  1245.         }
  1246.         return _cache;
  1247.     }
  1248.  
  1249. protected:
  1250.     inline GSLPlayObject(GSLPlayObject_base* b) : Arts::Object(b), _cache(0) {}
  1251.  
  1252.  
  1253. public:
  1254.     typedef GSLPlayObject_base _base_class;
  1255.  
  1256.     inline GSLPlayObject() : Arts::Object(_Creator), _cache(0) {}
  1257.     inline GSLPlayObject(const Arts::SubClass& s) :
  1258.         Arts::Object(GSLPlayObject_base::_create(s.string())), _cache(0) {}
  1259.     inline GSLPlayObject(const Arts::Reference &r) :
  1260.         Arts::Object(r.isString()?(GSLPlayObject_base::_fromString(r.string())):(GSLPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  1261.     inline GSLPlayObject(const Arts::DynamicCast& c) : Arts::Object(GSLPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  1262.     inline GSLPlayObject(const GSLPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1263.     inline GSLPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1264.     inline static GSLPlayObject null() {return GSLPlayObject((GSLPlayObject_base*)0);}
  1265.     inline static GSLPlayObject _from_base(GSLPlayObject_base* b) {return GSLPlayObject(b);}
  1266.     inline GSLPlayObject& operator=(const GSLPlayObject& target) {
  1267.         if (_pool == target._pool) return *this;
  1268.         _pool->Dec();
  1269.         _pool = target._pool;
  1270.         _cache = target._cache;
  1271.         _pool->Inc();
  1272.         return *this;
  1273.     }
  1274.     inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
  1275.     inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
  1276.     inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
  1277.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1278.     inline GSLPlayObject_base* _base() {return _cache?_cache:_method_call();}
  1279.  
  1280.     inline std::string description();
  1281.     inline Arts::poTime currentTime();
  1282.     inline Arts::poTime overallTime();
  1283.     inline Arts::poCapabilities capabilities();
  1284.     inline std::string mediaName();
  1285.     inline Arts::poState state();
  1286.     inline void play();
  1287.     inline void seek(const Arts::poTime& newTime);
  1288.     inline void pause();
  1289.     inline void halt();
  1290.     inline bool loadMedia(const std::string& filename);
  1291.     inline float speed();
  1292.     inline void speed(float _newValue);
  1293.     inline Arts::AutoSuspendState autoSuspend();
  1294.     inline void start();
  1295.     inline void stop();
  1296.     inline void streamInit();
  1297.     inline void streamStart();
  1298.     inline void streamEnd();
  1299.     inline bool done();
  1300.     inline void done(bool _newValue);
  1301. };
  1302.  
  1303. class ARTS_EXPORT SoundServerStartup_base : virtual public Arts::Object_base {
  1304. public:
  1305.     static unsigned long _IID; // interface ID
  1306.  
  1307.     static SoundServerStartup_base *_create(const std::string& subClass = "Arts::SoundServerStartup");
  1308.     static SoundServerStartup_base *_fromString(const std::string& objectref);
  1309.     static SoundServerStartup_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1310.  
  1311.     static SoundServerStartup_base *_fromDynamicCast(const Arts::Object& object);
  1312.     inline SoundServerStartup_base *_copy() {
  1313.         assert(_refCnt > 0);
  1314.         _refCnt++;
  1315.         return this;
  1316.     }
  1317.  
  1318.     virtual std::vector<std::string> _defaultPortsIn() const;
  1319.     virtual std::vector<std::string> _defaultPortsOut() const;
  1320.  
  1321.     void *_cast(unsigned long iid);
  1322.  
  1323.     virtual void lock() = 0;
  1324.     virtual void unlock() = 0;
  1325. };
  1326.  
  1327. class ARTS_EXPORT SoundServerStartup_stub : virtual public SoundServerStartup_base, virtual public Arts::Object_stub {
  1328. protected:
  1329.     SoundServerStartup_stub();
  1330.  
  1331. public:
  1332.     SoundServerStartup_stub(Arts::Connection *connection, long objectID);
  1333.  
  1334.     void lock();
  1335.     void unlock();
  1336. };
  1337.  
  1338. class ARTS_EXPORT SoundServerStartup_skel : virtual public SoundServerStartup_base, virtual public Arts::Object_skel {
  1339. public:
  1340.     SoundServerStartup_skel();
  1341.  
  1342.     static std::string _interfaceNameSkel();
  1343.     std::string _interfaceName();
  1344.     bool _isCompatibleWith(const std::string& interfacename);
  1345.     void _buildMethodTable();
  1346.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1347. };
  1348.  
  1349. }
  1350. #include "reference.h"
  1351. namespace Arts {
  1352. class ARTS_EXPORT SoundServerStartup : public Arts::Object {
  1353. private:
  1354.     static Arts::Object_base* _Creator();
  1355.     SoundServerStartup_base *_cache;
  1356.     inline SoundServerStartup_base *_method_call() {
  1357.         _pool->checkcreate();
  1358.         if(_pool->base) {
  1359.             _cache=(SoundServerStartup_base *)_pool->base->_cast(SoundServerStartup_base::_IID);
  1360.             assert(_cache);
  1361.         }
  1362.         return _cache;
  1363.     }
  1364.  
  1365. protected:
  1366.     inline SoundServerStartup(SoundServerStartup_base* b) : Arts::Object(b), _cache(0) {}
  1367.  
  1368.  
  1369. public:
  1370.     typedef SoundServerStartup_base _base_class;
  1371.  
  1372.     inline SoundServerStartup() : Arts::Object(_Creator), _cache(0) {}
  1373.     inline SoundServerStartup(const Arts::SubClass& s) :
  1374.         Arts::Object(SoundServerStartup_base::_create(s.string())), _cache(0) {}
  1375.     inline SoundServerStartup(const Arts::Reference &r) :
  1376.         Arts::Object(r.isString()?(SoundServerStartup_base::_fromString(r.string())):(SoundServerStartup_base::_fromReference(r.reference(),true))), _cache(0) {}
  1377.     inline SoundServerStartup(const Arts::DynamicCast& c) : Arts::Object(SoundServerStartup_base::_fromDynamicCast(c.object())), _cache(0) {}
  1378.     inline SoundServerStartup(const SoundServerStartup& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1379.     inline SoundServerStartup(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1380.     inline static SoundServerStartup null() {return SoundServerStartup((SoundServerStartup_base*)0);}
  1381.     inline static SoundServerStartup _from_base(SoundServerStartup_base* b) {return SoundServerStartup(b);}
  1382.     inline SoundServerStartup& operator=(const SoundServerStartup& target) {
  1383.         if (_pool == target._pool) return *this;
  1384.         _pool->Dec();
  1385.         _pool = target._pool;
  1386.         _cache = target._cache;
  1387.         _pool->Inc();
  1388.         return *this;
  1389.     }
  1390.     inline SoundServerStartup_base* _base() {return _cache?_cache:_method_call();}
  1391.  
  1392.     inline void lock();
  1393.     inline void unlock();
  1394. };
  1395.  
  1396. }
  1397. // Forward wrapper calls to _base classes:
  1398.  
  1399. inline std::string Arts::SampleStorageEntry::name()
  1400. {
  1401.     return _cache?static_cast<Arts::SampleStorageEntry_base*>(_cache)->name():static_cast<Arts::SampleStorageEntry_base*>(_method_call())->name();
  1402. }
  1403.  
  1404. inline std::string Arts::SampleStorageEntry::filename()
  1405. {
  1406.     return _cache?static_cast<Arts::SampleStorageEntry_base*>(_cache)->filename():static_cast<Arts::SampleStorageEntry_base*>(_method_call())->filename();
  1407. }
  1408.  
  1409. inline bool Arts::SampleStorageEntry::completed()
  1410. {
  1411.     return _cache?static_cast<Arts::SampleStorageEntry_base*>(_cache)->completed():static_cast<Arts::SampleStorageEntry_base*>(_method_call())->completed();
  1412. }
  1413.  
  1414. inline void Arts::SampleStorageEntry::write(const std::vector<Arts::mcopbyte>& data)
  1415. {
  1416.      _cache?static_cast<Arts::SampleStorageEntry_base*>(_cache)->write(data):static_cast<Arts::SampleStorageEntry_base*>(_method_call())->write(data);
  1417. }
  1418.  
  1419. inline void Arts::SampleStorageEntry::finish()
  1420. {
  1421.      _cache?static_cast<Arts::SampleStorageEntry_base*>(_cache)->finish():static_cast<Arts::SampleStorageEntry_base*>(_method_call())->finish();
  1422. }
  1423.  
  1424. inline Arts::SampleStorage::SampleStorage(const std::string& directory, bool clearOnInit)
  1425.         : Arts::Object(SampleStorage_base::_create())
  1426. {
  1427.     static_cast<Arts::SampleStorage_base*>(_method_call())->constructor(directory, clearOnInit);
  1428. }
  1429.  
  1430. inline Arts::SampleStorageEntry Arts::SampleStorage::createEntry(const std::string& name)
  1431. {
  1432.     return _cache?static_cast<Arts::SampleStorage_base*>(_cache)->createEntry(name):static_cast<Arts::SampleStorage_base*>(_method_call())->createEntry(name);
  1433. }
  1434.  
  1435. inline void Arts::SampleStorage::addEntry(Arts::SampleStorageEntry entry)
  1436. {
  1437.      _cache?static_cast<Arts::SampleStorage_base*>(_cache)->addEntry(entry):static_cast<Arts::SampleStorage_base*>(_method_call())->addEntry(entry);
  1438. }
  1439.  
  1440. inline void Arts::SampleStorage::removeEntry(Arts::SampleStorageEntry entry)
  1441. {
  1442.      _cache?static_cast<Arts::SampleStorage_base*>(_cache)->removeEntry(entry):static_cast<Arts::SampleStorage_base*>(_method_call())->removeEntry(entry);
  1443. }
  1444.  
  1445. inline Arts::SampleStorageEntry Arts::SampleStorage::findEntry(const std::string& name)
  1446. {
  1447.     return _cache?static_cast<Arts::SampleStorage_base*>(_cache)->findEntry(name):static_cast<Arts::SampleStorage_base*>(_method_call())->findEntry(name);
  1448. }
  1449.  
  1450. inline Arts::AutoSuspendState Arts::ByteSoundProducer::autoSuspend()
  1451. {
  1452.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1453. }
  1454.  
  1455. inline void Arts::ByteSoundProducer::start()
  1456. {
  1457.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1458. }
  1459.  
  1460. inline void Arts::ByteSoundProducer::stop()
  1461. {
  1462.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1463. }
  1464.  
  1465. inline void Arts::ByteSoundProducer::streamInit()
  1466. {
  1467.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1468. }
  1469.  
  1470. inline void Arts::ByteSoundProducer::streamStart()
  1471. {
  1472.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1473. }
  1474.  
  1475. inline void Arts::ByteSoundProducer::streamEnd()
  1476. {
  1477.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1478. }
  1479.  
  1480. inline long Arts::ByteSoundProducer::samplingRate()
  1481. {
  1482.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->samplingRate():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->samplingRate();
  1483. }
  1484.  
  1485. inline long Arts::ByteSoundProducer::channels()
  1486. {
  1487.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->channels():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->channels();
  1488. }
  1489.  
  1490. inline long Arts::ByteSoundProducer::bits()
  1491. {
  1492.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->bits():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->bits();
  1493. }
  1494.  
  1495. inline long Arts::ByteSoundProducerV2::samplingRate()
  1496. {
  1497.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->samplingRate():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->samplingRate();
  1498. }
  1499.  
  1500. inline long Arts::ByteSoundProducerV2::channels()
  1501. {
  1502.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->channels():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->channels();
  1503. }
  1504.  
  1505. inline long Arts::ByteSoundProducerV2::bits()
  1506. {
  1507.     return _cache?static_cast<Arts::ByteSoundProducer_base*>(_cache)->bits():static_cast<Arts::ByteSoundProducer_base*>(_method_call())->bits();
  1508. }
  1509.  
  1510. inline Arts::AutoSuspendState Arts::ByteSoundProducerV2::autoSuspend()
  1511. {
  1512.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1513. }
  1514.  
  1515. inline void Arts::ByteSoundProducerV2::start()
  1516. {
  1517.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1518. }
  1519.  
  1520. inline void Arts::ByteSoundProducerV2::stop()
  1521. {
  1522.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1523. }
  1524.  
  1525. inline void Arts::ByteSoundProducerV2::streamInit()
  1526. {
  1527.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1528. }
  1529.  
  1530. inline void Arts::ByteSoundProducerV2::streamStart()
  1531. {
  1532.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1533. }
  1534.  
  1535. inline void Arts::ByteSoundProducerV2::streamEnd()
  1536. {
  1537.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1538. }
  1539.  
  1540. inline std::string Arts::ByteSoundProducerV2::title()
  1541. {
  1542.     return _cache?static_cast<Arts::ByteSoundProducerV2_base*>(_cache)->title():static_cast<Arts::ByteSoundProducerV2_base*>(_method_call())->title();
  1543. }
  1544.  
  1545. inline Arts::AutoSuspendState Arts::ByteSoundReceiver::autoSuspend()
  1546. {
  1547.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1548. }
  1549.  
  1550. inline void Arts::ByteSoundReceiver::start()
  1551. {
  1552.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1553. }
  1554.  
  1555. inline void Arts::ByteSoundReceiver::stop()
  1556. {
  1557.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1558. }
  1559.  
  1560. inline void Arts::ByteSoundReceiver::streamInit()
  1561. {
  1562.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1563. }
  1564.  
  1565. inline void Arts::ByteSoundReceiver::streamStart()
  1566. {
  1567.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1568. }
  1569.  
  1570. inline void Arts::ByteSoundReceiver::streamEnd()
  1571. {
  1572.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1573. }
  1574.  
  1575. inline long Arts::ByteSoundReceiver::samplingRate()
  1576. {
  1577.     return _cache?static_cast<Arts::ByteSoundReceiver_base*>(_cache)->samplingRate():static_cast<Arts::ByteSoundReceiver_base*>(_method_call())->samplingRate();
  1578. }
  1579.  
  1580. inline long Arts::ByteSoundReceiver::channels()
  1581. {
  1582.     return _cache?static_cast<Arts::ByteSoundReceiver_base*>(_cache)->channels():static_cast<Arts::ByteSoundReceiver_base*>(_method_call())->channels();
  1583. }
  1584.  
  1585. inline long Arts::ByteSoundReceiver::bits()
  1586. {
  1587.     return _cache?static_cast<Arts::ByteSoundReceiver_base*>(_cache)->bits():static_cast<Arts::ByteSoundReceiver_base*>(_method_call())->bits();
  1588. }
  1589.  
  1590. inline std::string Arts::ByteSoundReceiver::title()
  1591. {
  1592.     return _cache?static_cast<Arts::ByteSoundReceiver_base*>(_cache)->title():static_cast<Arts::ByteSoundReceiver_base*>(_method_call())->title();
  1593. }
  1594.  
  1595. inline Arts::PlayObject Arts::SimpleSoundServer::createPlayObject(const std::string& filename)
  1596. {
  1597.     return _cache?static_cast<Arts::PlayObjectFactory_base*>(_cache)->createPlayObject(filename):static_cast<Arts::PlayObjectFactory_base*>(_method_call())->createPlayObject(filename);
  1598. }
  1599.  
  1600. inline Arts::StereoEffectStack Arts::SimpleSoundServer::outstack()
  1601. {
  1602.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->outstack():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->outstack();
  1603. }
  1604.  
  1605. inline float Arts::SimpleSoundServer::minStreamBufferTime()
  1606. {
  1607.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->minStreamBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->minStreamBufferTime();
  1608. }
  1609.  
  1610. inline float Arts::SimpleSoundServer::serverBufferTime()
  1611. {
  1612.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->serverBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->serverBufferTime();
  1613. }
  1614.  
  1615. inline long Arts::SimpleSoundServer::play(const std::string& filename)
  1616. {
  1617.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->play(filename):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->play(filename);
  1618. }
  1619.  
  1620. inline void Arts::SimpleSoundServer::attach(Arts::ByteSoundProducer producer)
  1621. {
  1622.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attach(producer);
  1623. }
  1624.  
  1625. inline void Arts::SimpleSoundServer::detach(Arts::ByteSoundProducer producer)
  1626. {
  1627.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detach(producer);
  1628. }
  1629.  
  1630. inline void Arts::SimpleSoundServer::attachRecorder(Arts::ByteSoundReceiver receiver)
  1631. {
  1632.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attachRecorder(receiver);
  1633. }
  1634.  
  1635. inline void Arts::SimpleSoundServer::detachRecorder(Arts::ByteSoundReceiver receiver)
  1636. {
  1637.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detachRecorder(receiver);
  1638. }
  1639.  
  1640. inline Arts::Object Arts::SimpleSoundServer::createObject(const std::string& name)
  1641. {
  1642.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->createObject(name):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->createObject(name);
  1643. }
  1644.  
  1645. inline Arts::StereoEffectStack Arts::SoundServer::outstack()
  1646. {
  1647.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->outstack():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->outstack();
  1648. }
  1649.  
  1650. inline float Arts::SoundServer::minStreamBufferTime()
  1651. {
  1652.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->minStreamBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->minStreamBufferTime();
  1653. }
  1654.  
  1655. inline float Arts::SoundServer::serverBufferTime()
  1656. {
  1657.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->serverBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->serverBufferTime();
  1658. }
  1659.  
  1660. inline long Arts::SoundServer::play(const std::string& filename)
  1661. {
  1662.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->play(filename):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->play(filename);
  1663. }
  1664.  
  1665. inline void Arts::SoundServer::attach(Arts::ByteSoundProducer producer)
  1666. {
  1667.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attach(producer);
  1668. }
  1669.  
  1670. inline void Arts::SoundServer::detach(Arts::ByteSoundProducer producer)
  1671. {
  1672.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detach(producer);
  1673. }
  1674.  
  1675. inline void Arts::SoundServer::attachRecorder(Arts::ByteSoundReceiver receiver)
  1676. {
  1677.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attachRecorder(receiver);
  1678. }
  1679.  
  1680. inline void Arts::SoundServer::detachRecorder(Arts::ByteSoundReceiver receiver)
  1681. {
  1682.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detachRecorder(receiver);
  1683. }
  1684.  
  1685. inline Arts::Object Arts::SoundServer::createObject(const std::string& name)
  1686. {
  1687.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->createObject(name):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->createObject(name);
  1688. }
  1689.  
  1690. inline Arts::PlayObject Arts::SoundServer::createPlayObject(const std::string& filename)
  1691. {
  1692.     return _cache?static_cast<Arts::PlayObjectFactory_base*>(_cache)->createPlayObject(filename):static_cast<Arts::PlayObjectFactory_base*>(_method_call())->createPlayObject(filename);
  1693. }
  1694.  
  1695. inline Arts::RealtimeStatus Arts::SoundServer::realtimeStatus()
  1696. {
  1697.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->realtimeStatus():static_cast<Arts::SoundServer_base*>(_method_call())->realtimeStatus();
  1698. }
  1699.  
  1700. inline long Arts::SoundServer::secondsUntilSuspend()
  1701. {
  1702.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->secondsUntilSuspend():static_cast<Arts::SoundServer_base*>(_method_call())->secondsUntilSuspend();
  1703. }
  1704.  
  1705. inline bool Arts::SoundServer::suspend()
  1706. {
  1707.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->suspend():static_cast<Arts::SoundServer_base*>(_method_call())->suspend();
  1708. }
  1709.  
  1710. inline bool Arts::SoundServer::suspended()
  1711. {
  1712.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->suspended():static_cast<Arts::SoundServer_base*>(_method_call())->suspended();
  1713. }
  1714.  
  1715. inline bool Arts::SoundServer::terminate()
  1716. {
  1717.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->terminate():static_cast<Arts::SoundServer_base*>(_method_call())->terminate();
  1718. }
  1719.  
  1720. inline Arts::RealtimeStatus Arts::SoundServerV2::realtimeStatus()
  1721. {
  1722.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->realtimeStatus():static_cast<Arts::SoundServer_base*>(_method_call())->realtimeStatus();
  1723. }
  1724.  
  1725. inline long Arts::SoundServerV2::secondsUntilSuspend()
  1726. {
  1727.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->secondsUntilSuspend():static_cast<Arts::SoundServer_base*>(_method_call())->secondsUntilSuspend();
  1728. }
  1729.  
  1730. inline bool Arts::SoundServerV2::suspend()
  1731. {
  1732.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->suspend():static_cast<Arts::SoundServer_base*>(_method_call())->suspend();
  1733. }
  1734.  
  1735. inline bool Arts::SoundServerV2::suspended()
  1736. {
  1737.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->suspended():static_cast<Arts::SoundServer_base*>(_method_call())->suspended();
  1738. }
  1739.  
  1740. inline bool Arts::SoundServerV2::terminate()
  1741. {
  1742.     return _cache?static_cast<Arts::SoundServer_base*>(_cache)->terminate():static_cast<Arts::SoundServer_base*>(_method_call())->terminate();
  1743. }
  1744.  
  1745. inline Arts::StereoEffectStack Arts::SoundServerV2::outstack()
  1746. {
  1747.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->outstack():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->outstack();
  1748. }
  1749.  
  1750. inline float Arts::SoundServerV2::minStreamBufferTime()
  1751. {
  1752.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->minStreamBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->minStreamBufferTime();
  1753. }
  1754.  
  1755. inline float Arts::SoundServerV2::serverBufferTime()
  1756. {
  1757.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->serverBufferTime():static_cast<Arts::SimpleSoundServer_base*>(_method_call())->serverBufferTime();
  1758. }
  1759.  
  1760. inline long Arts::SoundServerV2::play(const std::string& filename)
  1761. {
  1762.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->play(filename):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->play(filename);
  1763. }
  1764.  
  1765. inline void Arts::SoundServerV2::attach(Arts::ByteSoundProducer producer)
  1766. {
  1767.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attach(producer);
  1768. }
  1769.  
  1770. inline void Arts::SoundServerV2::detach(Arts::ByteSoundProducer producer)
  1771. {
  1772.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detach(producer):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detach(producer);
  1773. }
  1774.  
  1775. inline void Arts::SoundServerV2::attachRecorder(Arts::ByteSoundReceiver receiver)
  1776. {
  1777.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->attachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->attachRecorder(receiver);
  1778. }
  1779.  
  1780. inline void Arts::SoundServerV2::detachRecorder(Arts::ByteSoundReceiver receiver)
  1781. {
  1782.      _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->detachRecorder(receiver):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->detachRecorder(receiver);
  1783. }
  1784.  
  1785. inline Arts::Object Arts::SoundServerV2::createObject(const std::string& name)
  1786. {
  1787.     return _cache?static_cast<Arts::SimpleSoundServer_base*>(_cache)->createObject(name):static_cast<Arts::SimpleSoundServer_base*>(_method_call())->createObject(name);
  1788. }
  1789.  
  1790. inline Arts::PlayObject Arts::SoundServerV2::createPlayObject(const std::string& filename)
  1791. {
  1792.     return _cache?static_cast<Arts::PlayObjectFactory_base*>(_cache)->createPlayObject(filename):static_cast<Arts::PlayObjectFactory_base*>(_method_call())->createPlayObject(filename);
  1793. }
  1794.  
  1795. inline Arts::PlayObject Arts::SoundServerV2::createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS)
  1796. {
  1797.     return _cache?static_cast<Arts::PlayObjectFactoryV2_base*>(_cache)->createPlayObjectForURL(url, mimetype, createBUS):static_cast<Arts::PlayObjectFactoryV2_base*>(_method_call())->createPlayObjectForURL(url, mimetype, createBUS);
  1798. }
  1799.  
  1800. inline Arts::PlayObject Arts::SoundServerV2::createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS)
  1801. {
  1802.     return _cache?static_cast<Arts::PlayObjectFactoryV2_base*>(_cache)->createPlayObjectForStream(instream, mimetype, createBUS):static_cast<Arts::PlayObjectFactoryV2_base*>(_method_call())->createPlayObjectForStream(instream, mimetype, createBUS);
  1803. }
  1804.  
  1805. inline long Arts::SoundServerV2::autoSuspendSeconds()
  1806. {
  1807.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->autoSuspendSeconds():static_cast<Arts::SoundServerV2_base*>(_method_call())->autoSuspendSeconds();
  1808. }
  1809.  
  1810. inline void Arts::SoundServerV2::autoSuspendSeconds(long _newValue)
  1811. {
  1812.      _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->autoSuspendSeconds(_newValue):static_cast<Arts::SoundServerV2_base*>(_method_call())->autoSuspendSeconds(_newValue);
  1813. }
  1814.  
  1815. inline long Arts::SoundServerV2::bufferSizeMultiplier()
  1816. {
  1817.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->bufferSizeMultiplier():static_cast<Arts::SoundServerV2_base*>(_method_call())->bufferSizeMultiplier();
  1818. }
  1819.  
  1820. inline void Arts::SoundServerV2::bufferSizeMultiplier(long _newValue)
  1821. {
  1822.      _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->bufferSizeMultiplier(_newValue):static_cast<Arts::SoundServerV2_base*>(_method_call())->bufferSizeMultiplier(_newValue);
  1823. }
  1824.  
  1825. inline float Arts::SoundServerV2::cpuUsage()
  1826. {
  1827.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->cpuUsage():static_cast<Arts::SoundServerV2_base*>(_method_call())->cpuUsage();
  1828. }
  1829.  
  1830. inline std::string Arts::SoundServerV2::audioMethod()
  1831. {
  1832.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->audioMethod():static_cast<Arts::SoundServerV2_base*>(_method_call())->audioMethod();
  1833. }
  1834.  
  1835. inline long Arts::SoundServerV2::samplingRate()
  1836. {
  1837.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->samplingRate():static_cast<Arts::SoundServerV2_base*>(_method_call())->samplingRate();
  1838. }
  1839.  
  1840. inline long Arts::SoundServerV2::channels()
  1841. {
  1842.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->channels():static_cast<Arts::SoundServerV2_base*>(_method_call())->channels();
  1843. }
  1844.  
  1845. inline long Arts::SoundServerV2::bits()
  1846. {
  1847.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->bits():static_cast<Arts::SoundServerV2_base*>(_method_call())->bits();
  1848. }
  1849.  
  1850. inline bool Arts::SoundServerV2::fullDuplex()
  1851. {
  1852.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->fullDuplex():static_cast<Arts::SoundServerV2_base*>(_method_call())->fullDuplex();
  1853. }
  1854.  
  1855. inline std::string Arts::SoundServerV2::audioDevice()
  1856. {
  1857.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->audioDevice():static_cast<Arts::SoundServerV2_base*>(_method_call())->audioDevice();
  1858. }
  1859.  
  1860. inline long Arts::SoundServerV2::fragments()
  1861. {
  1862.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->fragments():static_cast<Arts::SoundServerV2_base*>(_method_call())->fragments();
  1863. }
  1864.  
  1865. inline long Arts::SoundServerV2::fragmentSize()
  1866. {
  1867.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->fragmentSize():static_cast<Arts::SoundServerV2_base*>(_method_call())->fragmentSize();
  1868. }
  1869.  
  1870. inline std::string Arts::SoundServerV2::version()
  1871. {
  1872.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->version():static_cast<Arts::SoundServerV2_base*>(_method_call())->version();
  1873. }
  1874.  
  1875. inline Arts::StereoVolumeControl Arts::SoundServerV2::outVolume()
  1876. {
  1877.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->outVolume():static_cast<Arts::SoundServerV2_base*>(_method_call())->outVolume();
  1878. }
  1879.  
  1880. inline Arts::SampleStorage Arts::SoundServerV2::sampleStorage()
  1881. {
  1882.     return _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->sampleStorage():static_cast<Arts::SoundServerV2_base*>(_method_call())->sampleStorage();
  1883. }
  1884.  
  1885. inline void Arts::SoundServerV2::checkNewObjects()
  1886. {
  1887.      _cache?static_cast<Arts::SoundServerV2_base*>(_cache)->checkNewObjects():static_cast<Arts::SoundServerV2_base*>(_method_call())->checkNewObjects();
  1888. }
  1889.  
  1890. inline std::string Arts::WavPlayObject::description()
  1891. {
  1892.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
  1893. }
  1894.  
  1895. inline Arts::poTime Arts::WavPlayObject::currentTime()
  1896. {
  1897.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
  1898. }
  1899.  
  1900. inline Arts::poTime Arts::WavPlayObject::overallTime()
  1901. {
  1902.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
  1903. }
  1904.  
  1905. inline Arts::poCapabilities Arts::WavPlayObject::capabilities()
  1906. {
  1907.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
  1908. }
  1909.  
  1910. inline std::string Arts::WavPlayObject::mediaName()
  1911. {
  1912.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
  1913. }
  1914.  
  1915. inline Arts::poState Arts::WavPlayObject::state()
  1916. {
  1917.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
  1918. }
  1919.  
  1920. inline void Arts::WavPlayObject::play()
  1921. {
  1922.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
  1923. }
  1924.  
  1925. inline void Arts::WavPlayObject::seek(const Arts::poTime& newTime)
  1926. {
  1927.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
  1928. }
  1929.  
  1930. inline void Arts::WavPlayObject::pause()
  1931. {
  1932.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
  1933. }
  1934.  
  1935. inline void Arts::WavPlayObject::halt()
  1936. {
  1937.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
  1938. }
  1939.  
  1940. inline bool Arts::WavPlayObject::loadMedia(const std::string& filename)
  1941. {
  1942.     return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
  1943. }
  1944.  
  1945. inline Arts::AutoSuspendState Arts::WavPlayObject::autoSuspend()
  1946. {
  1947.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1948. }
  1949.  
  1950. inline void Arts::WavPlayObject::start()
  1951. {
  1952.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1953. }
  1954.  
  1955. inline void Arts::WavPlayObject::stop()
  1956. {
  1957.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1958. }
  1959.  
  1960. inline void Arts::WavPlayObject::streamInit()
  1961. {
  1962.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1963. }
  1964.  
  1965. inline void Arts::WavPlayObject::streamStart()
  1966. {
  1967.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1968. }
  1969.  
  1970. inline void Arts::WavPlayObject::streamEnd()
  1971. {
  1972.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1973. }
  1974.  
  1975. inline std::string Arts::GSLPlayObject::description()
  1976. {
  1977.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
  1978. }
  1979.  
  1980. inline Arts::poTime Arts::GSLPlayObject::currentTime()
  1981. {
  1982.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
  1983. }
  1984.  
  1985. inline Arts::poTime Arts::GSLPlayObject::overallTime()
  1986. {
  1987.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
  1988. }
  1989.  
  1990. inline Arts::poCapabilities Arts::GSLPlayObject::capabilities()
  1991. {
  1992.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
  1993. }
  1994.  
  1995. inline std::string Arts::GSLPlayObject::mediaName()
  1996. {
  1997.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
  1998. }
  1999.  
  2000. inline Arts::poState Arts::GSLPlayObject::state()
  2001. {
  2002.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
  2003. }
  2004.  
  2005. inline void Arts::GSLPlayObject::play()
  2006. {
  2007.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
  2008. }
  2009.  
  2010. inline void Arts::GSLPlayObject::seek(const Arts::poTime& newTime)
  2011. {
  2012.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
  2013. }
  2014.  
  2015. inline void Arts::GSLPlayObject::pause()
  2016. {
  2017.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
  2018. }
  2019.  
  2020. inline void Arts::GSLPlayObject::halt()
  2021. {
  2022.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
  2023. }
  2024.  
  2025. inline bool Arts::GSLPlayObject::loadMedia(const std::string& filename)
  2026. {
  2027.     return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
  2028. }
  2029.  
  2030. inline float Arts::GSLPlayObject::speed()
  2031. {
  2032.     return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
  2033. }
  2034.  
  2035. inline void Arts::GSLPlayObject::speed(float _newValue)
  2036. {
  2037.      _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
  2038. }
  2039.  
  2040. inline Arts::AutoSuspendState Arts::GSLPlayObject::autoSuspend()
  2041. {
  2042.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  2043. }
  2044.  
  2045. inline void Arts::GSLPlayObject::start()
  2046. {
  2047.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  2048. }
  2049.  
  2050. inline void Arts::GSLPlayObject::stop()
  2051. {
  2052.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  2053. }
  2054.  
  2055. inline void Arts::GSLPlayObject::streamInit()
  2056. {
  2057.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  2058. }
  2059.  
  2060. inline void Arts::GSLPlayObject::streamStart()
  2061. {
  2062.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  2063. }
  2064.  
  2065. inline void Arts::GSLPlayObject::streamEnd()
  2066. {
  2067.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  2068. }
  2069.  
  2070. inline bool Arts::GSLPlayObject::done()
  2071. {
  2072.     return _cache?static_cast<Arts::GSLPlayObject_base*>(_cache)->done():static_cast<Arts::GSLPlayObject_base*>(_method_call())->done();
  2073. }
  2074.  
  2075. inline void Arts::GSLPlayObject::done(bool _newValue)
  2076. {
  2077.      _cache?static_cast<Arts::GSLPlayObject_base*>(_cache)->done(_newValue):static_cast<Arts::GSLPlayObject_base*>(_method_call())->done(_newValue);
  2078. }
  2079.  
  2080. inline void Arts::SoundServerStartup::lock()
  2081. {
  2082.      _cache?static_cast<Arts::SoundServerStartup_base*>(_cache)->lock():static_cast<Arts::SoundServerStartup_base*>(_method_call())->lock();
  2083. }
  2084.  
  2085. inline void Arts::SoundServerStartup::unlock()
  2086. {
  2087.      _cache?static_cast<Arts::SoundServerStartup_base*>(_cache)->unlock():static_cast<Arts::SoundServerStartup_base*>(_method_call())->unlock();
  2088. }
  2089.  
  2090. #endif /* SOUNDSERVER_H */
  2091.