/* this file was generated by the MCOP idl compiler - DO NOT EDIT */

#ifndef DECODERBASEOBJECT_H
#define DECODERBASEOBJECT_H

#include "common.h"

// includes of other idl definitions
#include "kmedia2.h"
#include "artsflow.h"

class DecoderBaseObject;
class MP3PlayObject;
class WAVPlayObject;
class MPGPlayObject;
class OGGPlayObject;
class CDDAPlayObject;
class VCDPlayObject;
class NULLPlayObject;

class DecoderBaseObject_base : virtual public Arts::StreamPlayObject_base,
	virtual public Arts::SynthModule_base,
	virtual public Arts::PitchablePlayObject_base {
public:
	static unsigned long _IID; // interface ID

	static DecoderBaseObject_base *_create(const std::string& subClass = "DecoderBaseObject");
	static DecoderBaseObject_base *_fromString(const std::string& objectref);
	static DecoderBaseObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static DecoderBaseObject_base *_fromDynamicCast(const Arts::Object& object);
	inline DecoderBaseObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

	virtual bool blocking() = 0;
	virtual void blocking(bool newValue) = 0;
};

class DecoderBaseObject_stub : virtual public DecoderBaseObject_base, virtual public Arts::StreamPlayObject_stub,
	virtual public Arts::SynthModule_stub,
	virtual public Arts::PitchablePlayObject_stub {
protected:
	DecoderBaseObject_stub();

public:
	DecoderBaseObject_stub(Arts::Connection *connection, long objectID);

	bool blocking();
	void blocking(bool newValue);
};

class DecoderBaseObject_skel : virtual public DecoderBaseObject_base, virtual public Arts::StreamPlayObject_skel,
	virtual public Arts::SynthModule_skel,
	virtual public Arts::PitchablePlayObject_skel {
protected:
	// variables for streams
	Arts::ByteAsyncStream indata;             // incoming stream

	// handler for asynchronous streams
	virtual void process_indata(Arts::DataPacket<Arts::mcopbyte> *) = 0;

protected:
	// emitters for change notifications
	inline void blocking_changed(bool newValue) {
		_emit_changed("blocking_changed",newValue);
	}

public:
	DecoderBaseObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
	void notify(const Arts::Notification& notification);
};

#include "reference.h"
class DecoderBaseObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	DecoderBaseObject_base *_cache;
	inline DecoderBaseObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(DecoderBaseObject_base *)_pool->base->_cast(DecoderBaseObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline DecoderBaseObject(DecoderBaseObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef DecoderBaseObject_base _base_class;

	inline DecoderBaseObject() : Arts::Object(_Creator), _cache(0) {}
	inline DecoderBaseObject(const Arts::SubClass& s) :
		Arts::Object(DecoderBaseObject_base::_create(s.string())), _cache(0) {}
	inline DecoderBaseObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(DecoderBaseObject_base::_fromString(r.string())):(DecoderBaseObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline DecoderBaseObject(const Arts::DynamicCast& c) : Arts::Object(DecoderBaseObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline DecoderBaseObject(const DecoderBaseObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline DecoderBaseObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static DecoderBaseObject null() {return DecoderBaseObject((DecoderBaseObject_base*)0);}
	inline static DecoderBaseObject _from_base(DecoderBaseObject_base* b) {return DecoderBaseObject(b);}
	inline DecoderBaseObject& operator=(const DecoderBaseObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline DecoderBaseObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
	inline bool blocking();
	inline void blocking(bool _newValue);
};

class MP3PlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static MP3PlayObject_base *_create(const std::string& subClass = "MP3PlayObject");
	static MP3PlayObject_base *_fromString(const std::string& objectref);
	static MP3PlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static MP3PlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline MP3PlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class MP3PlayObject_stub : virtual public MP3PlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	MP3PlayObject_stub();

public:
	MP3PlayObject_stub(Arts::Connection *connection, long objectID);

};

class MP3PlayObject_skel : virtual public MP3PlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	MP3PlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class MP3PlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	MP3PlayObject_base *_cache;
	inline MP3PlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(MP3PlayObject_base *)_pool->base->_cast(MP3PlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline MP3PlayObject(MP3PlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef MP3PlayObject_base _base_class;

	inline MP3PlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline MP3PlayObject(const Arts::SubClass& s) :
		Arts::Object(MP3PlayObject_base::_create(s.string())), _cache(0) {}
	inline MP3PlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(MP3PlayObject_base::_fromString(r.string())):(MP3PlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline MP3PlayObject(const Arts::DynamicCast& c) : Arts::Object(MP3PlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline MP3PlayObject(const MP3PlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline MP3PlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static MP3PlayObject null() {return MP3PlayObject((MP3PlayObject_base*)0);}
	inline static MP3PlayObject _from_base(MP3PlayObject_base* b) {return MP3PlayObject(b);}
	inline MP3PlayObject& operator=(const MP3PlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline MP3PlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class WAVPlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static WAVPlayObject_base *_create(const std::string& subClass = "WAVPlayObject");
	static WAVPlayObject_base *_fromString(const std::string& objectref);
	static WAVPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static WAVPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline WAVPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class WAVPlayObject_stub : virtual public WAVPlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	WAVPlayObject_stub();

public:
	WAVPlayObject_stub(Arts::Connection *connection, long objectID);

};

class WAVPlayObject_skel : virtual public WAVPlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	WAVPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class WAVPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	WAVPlayObject_base *_cache;
	inline WAVPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(WAVPlayObject_base *)_pool->base->_cast(WAVPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline WAVPlayObject(WAVPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef WAVPlayObject_base _base_class;

	inline WAVPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline WAVPlayObject(const Arts::SubClass& s) :
		Arts::Object(WAVPlayObject_base::_create(s.string())), _cache(0) {}
	inline WAVPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(WAVPlayObject_base::_fromString(r.string())):(WAVPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline WAVPlayObject(const Arts::DynamicCast& c) : Arts::Object(WAVPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline WAVPlayObject(const WAVPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline WAVPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static WAVPlayObject null() {return WAVPlayObject((WAVPlayObject_base*)0);}
	inline static WAVPlayObject _from_base(WAVPlayObject_base* b) {return WAVPlayObject(b);}
	inline WAVPlayObject& operator=(const WAVPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline WAVPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class MPGPlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static MPGPlayObject_base *_create(const std::string& subClass = "MPGPlayObject");
	static MPGPlayObject_base *_fromString(const std::string& objectref);
	static MPGPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static MPGPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline MPGPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class MPGPlayObject_stub : virtual public MPGPlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	MPGPlayObject_stub();

public:
	MPGPlayObject_stub(Arts::Connection *connection, long objectID);

};

class MPGPlayObject_skel : virtual public MPGPlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	MPGPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class MPGPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	MPGPlayObject_base *_cache;
	inline MPGPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(MPGPlayObject_base *)_pool->base->_cast(MPGPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline MPGPlayObject(MPGPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef MPGPlayObject_base _base_class;

	inline MPGPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline MPGPlayObject(const Arts::SubClass& s) :
		Arts::Object(MPGPlayObject_base::_create(s.string())), _cache(0) {}
	inline MPGPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(MPGPlayObject_base::_fromString(r.string())):(MPGPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline MPGPlayObject(const Arts::DynamicCast& c) : Arts::Object(MPGPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline MPGPlayObject(const MPGPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline MPGPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static MPGPlayObject null() {return MPGPlayObject((MPGPlayObject_base*)0);}
	inline static MPGPlayObject _from_base(MPGPlayObject_base* b) {return MPGPlayObject(b);}
	inline MPGPlayObject& operator=(const MPGPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline MPGPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class OGGPlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static OGGPlayObject_base *_create(const std::string& subClass = "OGGPlayObject");
	static OGGPlayObject_base *_fromString(const std::string& objectref);
	static OGGPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static OGGPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline OGGPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class OGGPlayObject_stub : virtual public OGGPlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	OGGPlayObject_stub();

public:
	OGGPlayObject_stub(Arts::Connection *connection, long objectID);

};

class OGGPlayObject_skel : virtual public OGGPlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	OGGPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class OGGPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	OGGPlayObject_base *_cache;
	inline OGGPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(OGGPlayObject_base *)_pool->base->_cast(OGGPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline OGGPlayObject(OGGPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef OGGPlayObject_base _base_class;

	inline OGGPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline OGGPlayObject(const Arts::SubClass& s) :
		Arts::Object(OGGPlayObject_base::_create(s.string())), _cache(0) {}
	inline OGGPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(OGGPlayObject_base::_fromString(r.string())):(OGGPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline OGGPlayObject(const Arts::DynamicCast& c) : Arts::Object(OGGPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline OGGPlayObject(const OGGPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline OGGPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static OGGPlayObject null() {return OGGPlayObject((OGGPlayObject_base*)0);}
	inline static OGGPlayObject _from_base(OGGPlayObject_base* b) {return OGGPlayObject(b);}
	inline OGGPlayObject& operator=(const OGGPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline OGGPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class CDDAPlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static CDDAPlayObject_base *_create(const std::string& subClass = "CDDAPlayObject");
	static CDDAPlayObject_base *_fromString(const std::string& objectref);
	static CDDAPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static CDDAPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline CDDAPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class CDDAPlayObject_stub : virtual public CDDAPlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	CDDAPlayObject_stub();

public:
	CDDAPlayObject_stub(Arts::Connection *connection, long objectID);

};

class CDDAPlayObject_skel : virtual public CDDAPlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	CDDAPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class CDDAPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	CDDAPlayObject_base *_cache;
	inline CDDAPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(CDDAPlayObject_base *)_pool->base->_cast(CDDAPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline CDDAPlayObject(CDDAPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef CDDAPlayObject_base _base_class;

	inline CDDAPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline CDDAPlayObject(const Arts::SubClass& s) :
		Arts::Object(CDDAPlayObject_base::_create(s.string())), _cache(0) {}
	inline CDDAPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(CDDAPlayObject_base::_fromString(r.string())):(CDDAPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline CDDAPlayObject(const Arts::DynamicCast& c) : Arts::Object(CDDAPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline CDDAPlayObject(const CDDAPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline CDDAPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static CDDAPlayObject null() {return CDDAPlayObject((CDDAPlayObject_base*)0);}
	inline static CDDAPlayObject _from_base(CDDAPlayObject_base* b) {return CDDAPlayObject(b);}
	inline CDDAPlayObject& operator=(const CDDAPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline CDDAPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class VCDPlayObject_base : virtual public DecoderBaseObject_base {
public:
	static unsigned long _IID; // interface ID

	static VCDPlayObject_base *_create(const std::string& subClass = "VCDPlayObject");
	static VCDPlayObject_base *_fromString(const std::string& objectref);
	static VCDPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static VCDPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline VCDPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class VCDPlayObject_stub : virtual public VCDPlayObject_base, virtual public DecoderBaseObject_stub {
protected:
	VCDPlayObject_stub();

public:
	VCDPlayObject_stub(Arts::Connection *connection, long objectID);

};

class VCDPlayObject_skel : virtual public VCDPlayObject_base, virtual public DecoderBaseObject_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	VCDPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class VCDPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	VCDPlayObject_base *_cache;
	inline VCDPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(VCDPlayObject_base *)_pool->base->_cast(VCDPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline VCDPlayObject(VCDPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef VCDPlayObject_base _base_class;

	inline VCDPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline VCDPlayObject(const Arts::SubClass& s) :
		Arts::Object(VCDPlayObject_base::_create(s.string())), _cache(0) {}
	inline VCDPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(VCDPlayObject_base::_fromString(r.string())):(VCDPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline VCDPlayObject(const Arts::DynamicCast& c) : Arts::Object(VCDPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline VCDPlayObject(const VCDPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline VCDPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static VCDPlayObject null() {return VCDPlayObject((VCDPlayObject_base*)0);}
	inline static VCDPlayObject _from_base(VCDPlayObject_base* b) {return VCDPlayObject(b);}
	inline VCDPlayObject& operator=(const VCDPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator DecoderBaseObject() const { return DecoderBaseObject(*_pool); }
	inline operator Arts::StreamPlayObject() const { return Arts::StreamPlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::PitchablePlayObject() const { return Arts::PitchablePlayObject(*_pool); }
	inline VCDPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline bool blocking();
	inline void blocking(bool _newValue);
	inline bool streamMedia(Arts::InputStream instream);
	inline Arts::InputStream inputStream();
	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
};

class NULLPlayObject_base : virtual public Arts::PlayObject_base,
	virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static NULLPlayObject_base *_create(const std::string& subClass = "NULLPlayObject");
	static NULLPlayObject_base *_fromString(const std::string& objectref);
	static NULLPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static NULLPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline NULLPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class NULLPlayObject_stub : virtual public NULLPlayObject_base, virtual public Arts::PlayObject_stub,
	virtual public Arts::SynthModule_stub {
protected:
	NULLPlayObject_stub();

public:
	NULLPlayObject_stub(Arts::Connection *connection, long objectID);

};

class NULLPlayObject_skel : virtual public NULLPlayObject_base, virtual public Arts::PlayObject_skel,
	virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	NULLPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class NULLPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	NULLPlayObject_base *_cache;
	inline NULLPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(NULLPlayObject_base *)_pool->base->_cast(NULLPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline NULLPlayObject(NULLPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef NULLPlayObject_base _base_class;

	inline NULLPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline NULLPlayObject(const Arts::SubClass& s) :
		Arts::Object(NULLPlayObject_base::_create(s.string())), _cache(0) {}
	inline NULLPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(NULLPlayObject_base::_fromString(r.string())):(NULLPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline NULLPlayObject(const Arts::DynamicCast& c) : Arts::Object(NULLPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline NULLPlayObject(const NULLPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline NULLPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static NULLPlayObject null() {return NULLPlayObject((NULLPlayObject_base*)0);}
	inline static NULLPlayObject _from_base(NULLPlayObject_base* b) {return NULLPlayObject(b);}
	inline NULLPlayObject& operator=(const NULLPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline NULLPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
};

// Forward wrapper calls to _base classes:

inline bool DecoderBaseObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream DecoderBaseObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string DecoderBaseObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime DecoderBaseObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime DecoderBaseObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities DecoderBaseObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string DecoderBaseObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState DecoderBaseObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void DecoderBaseObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void DecoderBaseObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void DecoderBaseObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void DecoderBaseObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool DecoderBaseObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState DecoderBaseObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void DecoderBaseObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void DecoderBaseObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void DecoderBaseObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void DecoderBaseObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void DecoderBaseObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float DecoderBaseObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void DecoderBaseObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool DecoderBaseObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void DecoderBaseObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool MP3PlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void MP3PlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool MP3PlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream MP3PlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string MP3PlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime MP3PlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime MP3PlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities MP3PlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string MP3PlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState MP3PlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void MP3PlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void MP3PlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void MP3PlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void MP3PlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool MP3PlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState MP3PlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void MP3PlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void MP3PlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void MP3PlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void MP3PlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void MP3PlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float MP3PlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void MP3PlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool WAVPlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void WAVPlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool WAVPlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream WAVPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string WAVPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime WAVPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime WAVPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities WAVPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string WAVPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState WAVPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void WAVPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void WAVPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void WAVPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void WAVPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool WAVPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState WAVPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void WAVPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void WAVPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void WAVPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void WAVPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void WAVPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float WAVPlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void WAVPlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool MPGPlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void MPGPlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool MPGPlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream MPGPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string MPGPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime MPGPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime MPGPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities MPGPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string MPGPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState MPGPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void MPGPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void MPGPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void MPGPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void MPGPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool MPGPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState MPGPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void MPGPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void MPGPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void MPGPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void MPGPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void MPGPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float MPGPlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void MPGPlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool OGGPlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void OGGPlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool OGGPlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream OGGPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string OGGPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime OGGPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime OGGPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities OGGPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string OGGPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState OGGPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void OGGPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void OGGPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void OGGPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void OGGPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool OGGPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState OGGPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void OGGPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void OGGPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void OGGPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void OGGPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void OGGPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float OGGPlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void OGGPlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool CDDAPlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void CDDAPlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool CDDAPlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream CDDAPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string CDDAPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime CDDAPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime CDDAPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities CDDAPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string CDDAPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState CDDAPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void CDDAPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void CDDAPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void CDDAPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void CDDAPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool CDDAPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState CDDAPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void CDDAPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void CDDAPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void CDDAPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void CDDAPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void CDDAPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float CDDAPlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void CDDAPlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline bool VCDPlayObject::blocking()
{
	return _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking():static_cast<DecoderBaseObject_base*>(_method_call())->blocking();
}

inline void VCDPlayObject::blocking(bool _newValue)
{
	 _cache?static_cast<DecoderBaseObject_base*>(_cache)->blocking(_newValue):static_cast<DecoderBaseObject_base*>(_method_call())->blocking(_newValue);
}

inline bool VCDPlayObject::streamMedia(Arts::InputStream instream)
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
}

inline Arts::InputStream VCDPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

inline std::string VCDPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime VCDPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime VCDPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities VCDPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string VCDPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState VCDPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void VCDPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void VCDPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void VCDPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void VCDPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool VCDPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState VCDPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void VCDPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void VCDPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void VCDPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void VCDPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void VCDPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float VCDPlayObject::speed()
{
	return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
}

inline void VCDPlayObject::speed(float _newValue)
{
	 _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
}

inline std::string NULLPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime NULLPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime NULLPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities NULLPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string NULLPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState NULLPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void NULLPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void NULLPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void NULLPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void NULLPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool NULLPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState NULLPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void NULLPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void NULLPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void NULLPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void NULLPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void NULLPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

#endif /* DECODERBASEOBJECT_H */
