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

#ifndef AKODEARTS_H
#define AKODEARTS_H

#include "common.h"

#include "arts_export.h"

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

class akodePlayObject;
class akodeMPCPlayObject;
class akodeMPEGPlayObject;
class akodeFFMPEGPlayObject;
class akodeXiphPlayObject;
class akodeFAADPlayObject;
class akodeVorbisStreamPlayObject;
class akodeSpeexStreamPlayObject;

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

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

	static akodePlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodePlayObject_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 ARTS_EXPORT akodePlayObject_stub : virtual public akodePlayObject_base, virtual public Arts::StreamPlayObject_stub,
	virtual public Arts::SynthModule_stub,
	virtual public Arts::PitchablePlayObject_stub {
protected:
	akodePlayObject_stub();

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

};

class ARTS_EXPORT akodePlayObject_skel : virtual public akodePlayObject_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
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

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

public:
	akodePlayObject_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 ARTS_EXPORT akodePlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodePlayObject_base *_cache;
	inline akodePlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodePlayObject_base *)_pool->base->_cast(akodePlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodePlayObject(akodePlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodePlayObject_base _base_class;

	inline akodePlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodePlayObject(const Arts::SubClass& s) :
		Arts::Object(akodePlayObject_base::_create(s.string())), _cache(0) {}
	inline akodePlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodePlayObject_base::_fromString(r.string())):(akodePlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodePlayObject(const Arts::DynamicCast& c) : Arts::Object(akodePlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodePlayObject(const akodePlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodePlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodePlayObject null() {return akodePlayObject((akodePlayObject_base*)0);}
	inline static akodePlayObject _from_base(akodePlayObject_base* b) {return akodePlayObject(b);}
	inline akodePlayObject& operator=(const akodePlayObject& 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 akodePlayObject_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);
};

class ARTS_EXPORT akodeMPCPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeMPCPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeMPCPlayObject_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 ARTS_EXPORT akodeMPCPlayObject_stub : virtual public akodeMPCPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeMPCPlayObject_stub();

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

};

class ARTS_EXPORT akodeMPCPlayObject_skel : virtual public akodeMPCPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeMPCPlayObject_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 ARTS_EXPORT akodeMPCPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeMPCPlayObject_base *_cache;
	inline akodeMPCPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeMPCPlayObject_base *)_pool->base->_cast(akodeMPCPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeMPCPlayObject(akodeMPCPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeMPCPlayObject_base _base_class;

	inline akodeMPCPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeMPCPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeMPCPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeMPCPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeMPCPlayObject_base::_fromString(r.string())):(akodeMPCPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeMPCPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeMPCPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeMPCPlayObject(const akodeMPCPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeMPCPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeMPCPlayObject null() {return akodeMPCPlayObject((akodeMPCPlayObject_base*)0);}
	inline static akodeMPCPlayObject _from_base(akodeMPCPlayObject_base* b) {return akodeMPCPlayObject(b);}
	inline akodeMPCPlayObject& operator=(const akodeMPCPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeMPCPlayObject_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);
};

class ARTS_EXPORT akodeMPEGPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeMPEGPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeMPEGPlayObject_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 ARTS_EXPORT akodeMPEGPlayObject_stub : virtual public akodeMPEGPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeMPEGPlayObject_stub();

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

};

class ARTS_EXPORT akodeMPEGPlayObject_skel : virtual public akodeMPEGPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeMPEGPlayObject_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 ARTS_EXPORT akodeMPEGPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeMPEGPlayObject_base *_cache;
	inline akodeMPEGPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeMPEGPlayObject_base *)_pool->base->_cast(akodeMPEGPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeMPEGPlayObject(akodeMPEGPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeMPEGPlayObject_base _base_class;

	inline akodeMPEGPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeMPEGPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeMPEGPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeMPEGPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeMPEGPlayObject_base::_fromString(r.string())):(akodeMPEGPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeMPEGPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeMPEGPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeMPEGPlayObject(const akodeMPEGPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeMPEGPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeMPEGPlayObject null() {return akodeMPEGPlayObject((akodeMPEGPlayObject_base*)0);}
	inline static akodeMPEGPlayObject _from_base(akodeMPEGPlayObject_base* b) {return akodeMPEGPlayObject(b);}
	inline akodeMPEGPlayObject& operator=(const akodeMPEGPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeMPEGPlayObject_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);
};

class ARTS_EXPORT akodeFFMPEGPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeFFMPEGPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeFFMPEGPlayObject_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 ARTS_EXPORT akodeFFMPEGPlayObject_stub : virtual public akodeFFMPEGPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeFFMPEGPlayObject_stub();

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

};

class ARTS_EXPORT akodeFFMPEGPlayObject_skel : virtual public akodeFFMPEGPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeFFMPEGPlayObject_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 ARTS_EXPORT akodeFFMPEGPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeFFMPEGPlayObject_base *_cache;
	inline akodeFFMPEGPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeFFMPEGPlayObject_base *)_pool->base->_cast(akodeFFMPEGPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeFFMPEGPlayObject(akodeFFMPEGPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeFFMPEGPlayObject_base _base_class;

	inline akodeFFMPEGPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeFFMPEGPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeFFMPEGPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeFFMPEGPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeFFMPEGPlayObject_base::_fromString(r.string())):(akodeFFMPEGPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeFFMPEGPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeFFMPEGPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeFFMPEGPlayObject(const akodeFFMPEGPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeFFMPEGPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeFFMPEGPlayObject null() {return akodeFFMPEGPlayObject((akodeFFMPEGPlayObject_base*)0);}
	inline static akodeFFMPEGPlayObject _from_base(akodeFFMPEGPlayObject_base* b) {return akodeFFMPEGPlayObject(b);}
	inline akodeFFMPEGPlayObject& operator=(const akodeFFMPEGPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeFFMPEGPlayObject_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);
};

class ARTS_EXPORT akodeXiphPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeXiphPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeXiphPlayObject_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 ARTS_EXPORT akodeXiphPlayObject_stub : virtual public akodeXiphPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeXiphPlayObject_stub();

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

};

class ARTS_EXPORT akodeXiphPlayObject_skel : virtual public akodeXiphPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeXiphPlayObject_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 ARTS_EXPORT akodeXiphPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeXiphPlayObject_base *_cache;
	inline akodeXiphPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeXiphPlayObject_base *)_pool->base->_cast(akodeXiphPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeXiphPlayObject(akodeXiphPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeXiphPlayObject_base _base_class;

	inline akodeXiphPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeXiphPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeXiphPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeXiphPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeXiphPlayObject_base::_fromString(r.string())):(akodeXiphPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeXiphPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeXiphPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeXiphPlayObject(const akodeXiphPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeXiphPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeXiphPlayObject null() {return akodeXiphPlayObject((akodeXiphPlayObject_base*)0);}
	inline static akodeXiphPlayObject _from_base(akodeXiphPlayObject_base* b) {return akodeXiphPlayObject(b);}
	inline akodeXiphPlayObject& operator=(const akodeXiphPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeXiphPlayObject_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);
};

class ARTS_EXPORT akodeFAADPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeFAADPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeFAADPlayObject_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 ARTS_EXPORT akodeFAADPlayObject_stub : virtual public akodeFAADPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeFAADPlayObject_stub();

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

};

class ARTS_EXPORT akodeFAADPlayObject_skel : virtual public akodeFAADPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeFAADPlayObject_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 ARTS_EXPORT akodeFAADPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeFAADPlayObject_base *_cache;
	inline akodeFAADPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeFAADPlayObject_base *)_pool->base->_cast(akodeFAADPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeFAADPlayObject(akodeFAADPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeFAADPlayObject_base _base_class;

	inline akodeFAADPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeFAADPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeFAADPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeFAADPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeFAADPlayObject_base::_fromString(r.string())):(akodeFAADPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeFAADPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeFAADPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeFAADPlayObject(const akodeFAADPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeFAADPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeFAADPlayObject null() {return akodeFAADPlayObject((akodeFAADPlayObject_base*)0);}
	inline static akodeFAADPlayObject _from_base(akodeFAADPlayObject_base* b) {return akodeFAADPlayObject(b);}
	inline akodeFAADPlayObject& operator=(const akodeFAADPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeFAADPlayObject_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);
};

class ARTS_EXPORT akodeVorbisStreamPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeVorbisStreamPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeVorbisStreamPlayObject_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 ARTS_EXPORT akodeVorbisStreamPlayObject_stub : virtual public akodeVorbisStreamPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeVorbisStreamPlayObject_stub();

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

};

class ARTS_EXPORT akodeVorbisStreamPlayObject_skel : virtual public akodeVorbisStreamPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeVorbisStreamPlayObject_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 ARTS_EXPORT akodeVorbisStreamPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeVorbisStreamPlayObject_base *_cache;
	inline akodeVorbisStreamPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeVorbisStreamPlayObject_base *)_pool->base->_cast(akodeVorbisStreamPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeVorbisStreamPlayObject(akodeVorbisStreamPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeVorbisStreamPlayObject_base _base_class;

	inline akodeVorbisStreamPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeVorbisStreamPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeVorbisStreamPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeVorbisStreamPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeVorbisStreamPlayObject_base::_fromString(r.string())):(akodeVorbisStreamPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeVorbisStreamPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeVorbisStreamPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeVorbisStreamPlayObject(const akodeVorbisStreamPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeVorbisStreamPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeVorbisStreamPlayObject null() {return akodeVorbisStreamPlayObject((akodeVorbisStreamPlayObject_base*)0);}
	inline static akodeVorbisStreamPlayObject _from_base(akodeVorbisStreamPlayObject_base* b) {return akodeVorbisStreamPlayObject(b);}
	inline akodeVorbisStreamPlayObject& operator=(const akodeVorbisStreamPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeVorbisStreamPlayObject_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);
};

class ARTS_EXPORT akodeSpeexStreamPlayObject_base : virtual public akodePlayObject_base {
public:
	static unsigned long _IID; // interface ID

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

	static akodeSpeexStreamPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline akodeSpeexStreamPlayObject_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 ARTS_EXPORT akodeSpeexStreamPlayObject_stub : virtual public akodeSpeexStreamPlayObject_base, virtual public akodePlayObject_stub {
protected:
	akodeSpeexStreamPlayObject_stub();

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

};

class ARTS_EXPORT akodeSpeexStreamPlayObject_skel : virtual public akodeSpeexStreamPlayObject_base, virtual public akodePlayObject_skel {
public:
	akodeSpeexStreamPlayObject_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 ARTS_EXPORT akodeSpeexStreamPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	akodeSpeexStreamPlayObject_base *_cache;
	inline akodeSpeexStreamPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(akodeSpeexStreamPlayObject_base *)_pool->base->_cast(akodeSpeexStreamPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline akodeSpeexStreamPlayObject(akodeSpeexStreamPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef akodeSpeexStreamPlayObject_base _base_class;

	inline akodeSpeexStreamPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline akodeSpeexStreamPlayObject(const Arts::SubClass& s) :
		Arts::Object(akodeSpeexStreamPlayObject_base::_create(s.string())), _cache(0) {}
	inline akodeSpeexStreamPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(akodeSpeexStreamPlayObject_base::_fromString(r.string())):(akodeSpeexStreamPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline akodeSpeexStreamPlayObject(const Arts::DynamicCast& c) : Arts::Object(akodeSpeexStreamPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline akodeSpeexStreamPlayObject(const akodeSpeexStreamPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline akodeSpeexStreamPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static akodeSpeexStreamPlayObject null() {return akodeSpeexStreamPlayObject((akodeSpeexStreamPlayObject_base*)0);}
	inline static akodeSpeexStreamPlayObject _from_base(akodeSpeexStreamPlayObject_base* b) {return akodeSpeexStreamPlayObject(b);}
	inline akodeSpeexStreamPlayObject& operator=(const akodeSpeexStreamPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator akodePlayObject() const { return akodePlayObject(*_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 akodeSpeexStreamPlayObject_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);
};

// Forward wrapper calls to _base classes:

inline bool akodePlayObject::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 akodePlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodePlayObject::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 akodePlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodePlayObject::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 akodePlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeMPCPlayObject::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 akodeMPCPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeMPCPlayObject::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 akodeMPCPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeMPCPlayObject::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 akodeMPCPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeMPEGPlayObject::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 akodeMPEGPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeMPEGPlayObject::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 akodeMPEGPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeMPEGPlayObject::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 akodeMPEGPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeFFMPEGPlayObject::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 akodeFFMPEGPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeFFMPEGPlayObject::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 akodeFFMPEGPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeFFMPEGPlayObject::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 akodeFFMPEGPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeXiphPlayObject::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 akodeXiphPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeXiphPlayObject::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 akodeXiphPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeXiphPlayObject::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 akodeXiphPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeFAADPlayObject::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 akodeFAADPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeFAADPlayObject::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 akodeFAADPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeFAADPlayObject::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 akodeFAADPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeVorbisStreamPlayObject::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 akodeVorbisStreamPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeVorbisStreamPlayObject::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 akodeVorbisStreamPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeVorbisStreamPlayObject::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 akodeVorbisStreamPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

inline bool akodeSpeexStreamPlayObject::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 akodeSpeexStreamPlayObject::inputStream()
{
	return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
}

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

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

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

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

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

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

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

inline void akodeSpeexStreamPlayObject::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 akodeSpeexStreamPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

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

inline bool akodeSpeexStreamPlayObject::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 akodeSpeexStreamPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

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

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

#endif /* AKODEARTS_H */
