builtin/moduleimpl.h ¶

Namespaces ¶

Name
cvedia
cvedia::rt API for controlling the server and lifecycle management of runtime instances.
cvedia::rt::iface
cvedia::rt::internal
cvedia::rt::module

Classes ¶

	Name
struct	cvedia::rt::module::PluginInit
struct	cvedia::rt::module::PluginLuaInit
struct	cvedia::rt::module::PluginTpl
struct	cvedia::rt::module::PluginInst
class	cvedia::rt::ModuleImpl

Types ¶

	Name
typedef const char ()()	_PluginName
typedef void(*)()	registerHandler
typedef void()(PluginInit init)	_Instantiate
typedef void()(PluginLuaInit init)	_InstantiateLua
using std::function< std::shared_ptr< iface::InferenceHandler >(std::string const &moduleName)>	createInferenceHandler
using std::function< std::shared_ptr< iface::InferenceEngine >(std::string const &moduleName)>	createInferenceEngine
using std::function< std::unique_ptr< iface::InputHandler >(std::string const &moduleName)>	createInputHandler
using std::function< std::shared_ptr< iface::OutputHandler >(std::string const &moduleName, std::string const &schema, std::string const &sink, std::string const &path, pCValue config)>	createOutputHandler
using std::function< std::unique_ptr< iface::VideoDecoder >(std::string const &deviceId, Codec const &codec)>	createVideoDecoderHandler
using std::function< std::shared_ptr< iface::SolutionManager >()>	createSolutionManagerHandler
using std::function< pCValue(std::string const &eventName, pCValue const &input)>	uiHandler

Defines ¶

	Name
	getConfigWithReadLock(varname)
	getConfigWithWriteLock(varname)
	getStateWithReadLock(varname)
	getStateWithWriteLock(varname)
	getStateConfigWithWWLock(state, config)
	getStateConfigWithRWLock(state, config)
	getStateConfigWithWRLock(state, config)
	getStateConfigWithRRLock(state, config)

Types Documentation ¶

typedef _PluginName ¶

typedef const char *(* _PluginName) ();

typedef registerHandler ¶

typedef void(* registerHandler) ();

typedef _Instantiate ¶

typedef void(* _Instantiate) (PluginInit *init);

typedef _InstantiateLua ¶

typedef void(* _InstantiateLua) (PluginLuaInit *init);

using createInferenceHandler ¶

using createInferenceHandler =  std::function<std::shared_ptr<iface::InferenceHandler>(std::string const& moduleName)>;

using createInferenceEngine ¶

using createInferenceEngine =  std::function<std::shared_ptr<iface::InferenceEngine>(std::string const& moduleName)>;

using createInputHandler ¶

using createInputHandler =  std::function<std::unique_ptr<iface::InputHandler>(std::string const& moduleName)>;

using createOutputHandler ¶

using createOutputHandler =  std::function<std::shared_ptr<iface::OutputHandler>(std::string const& moduleName, std::string const& schema, std::string const& sink, std::string const& path, pCValue config)>;

using createVideoDecoderHandler ¶

using createVideoDecoderHandler =  std::function<std::unique_ptr<iface::VideoDecoder>(std::string const& deviceId, Codec const& codec)>;

using createSolutionManagerHandler ¶

using createSolutionManagerHandler =  std::function<std::shared_ptr<iface::SolutionManager>()>;

using uiHandler ¶

using uiHandler =  std::function<pCValue(std::string const& eventName, pCValue const& input)>;

Macros Documentation ¶

define getConfigWithReadLock ¶

#define getConfigWithReadLock(
    varname
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvdict), getConfigDict()); \
    auto UNIQUE_NAME(lck) = UNIQUE_NAME(cvdict)->getReadLock(); \
    /*{ auto & t = *UNIQUE_NAME(lck).mutex(); LockMark(t); }*/ \
    auto const varname = UNIQUE_NAME(cvdict)->getNodeUnsafe() \

define getConfigWithWriteLock ¶

#define getConfigWithWriteLock(
    varname
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvdict), getConfigDict()); \
    auto UNIQUE_NAME(lck) = UNIQUE_NAME(cvdict)->getWriteLock(); \
    /*{ auto & t = *UNIQUE_NAME(lck).mutex(); LockMark(t); }*/ \
    auto const varname = UNIQUE_NAME(cvdict)->getNodeUnsafe() \

define getStateWithReadLock ¶

#define getStateWithReadLock(
    varname
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvdict), getStateDict()); \
    auto UNIQUE_NAME(lck) = UNIQUE_NAME(cvdict)->getReadLock(); \
    /*{ auto & t = *UNIQUE_NAME(lck).mutex(); LockMark(t); }*/ \
    auto const varname = UNIQUE_NAME(cvdict)->getNodeUnsafe() \

define getStateWithWriteLock ¶

#define getStateWithWriteLock(
    varname
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvdict), getStateDict()); \
    auto UNIQUE_NAME(lck) = UNIQUE_NAME(cvdict)->getWriteLock(); \
    /*{ auto & t = *UNIQUE_NAME(lck).mutex(); LockMark(t); }*/ \
    auto const varname = UNIQUE_NAME(cvdict)->getNodeUnsafe() \

define getStateConfigWithWWLock ¶

#define getStateConfigWithWWLock(
    state,
    config
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvstate), getStateDict()); \
    RT_TRY2(uCVDictRoot UNIQUE_NAME(cvconf), getConfigDict()); \
    auto UNIQUE_NAME(lck1) = UNIQUE_NAME(cvstate)->getWriteLockDefer(); \
    auto UNIQUE_NAME(lck2) = UNIQUE_NAME(cvconf)->getWriteLockDefer(); \
    std::lock(UNIQUE_NAME(lck1), UNIQUE_NAME(lck2)); \
    /*{ auto & t = *UNIQUE_NAME(lck1).mutex(); LockMark(t); } \
    { auto & t = *UNIQUE_NAME(lck2).mutex(); LockMark(t); } */ \
    auto const state = UNIQUE_NAME(cvstate)->getNodeUnsafe(); \
    auto const config = UNIQUE_NAME(cvconf)->getNodeUnsafe() \

define getStateConfigWithRWLock ¶

#define getStateConfigWithRWLock(
    state,
    config
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvstate), getStateDict()); \
    RT_TRY2(uCVDictRoot UNIQUE_NAME(cvconf), getConfigDict()); \
    auto UNIQUE_NAME(lck1) = UNIQUE_NAME(cvstate)->getReadLockDefer(); \
    auto UNIQUE_NAME(lck2) = UNIQUE_NAME(cvconf)->getWriteLockDefer(); \
    std::lock(UNIQUE_NAME(lck1), UNIQUE_NAME(lck2)); \
    /*{ auto & t = *UNIQUE_NAME(lck1).mutex(); LockMark(t); } \
    { auto & t = *UNIQUE_NAME(lck2).mutex(); LockMark(t); } */ \
    auto const state = UNIQUE_NAME(cvstate)->getNodeUnsafe(); \
    auto const config = UNIQUE_NAME(cvconf)->getNodeUnsafe() \

define getStateConfigWithWRLock ¶

#define getStateConfigWithWRLock(
    state,
    config
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvstate), getStateDict()); \
    RT_TRY2(uCVDictRoot UNIQUE_NAME(cvconf), getConfigDict()); \
    auto UNIQUE_NAME(lck1) = UNIQUE_NAME(cvstate)->getWriteLockDefer(); \
    auto UNIQUE_NAME(lck2) = UNIQUE_NAME(cvconf)->getReadLockDefer(); \
    std::lock(UNIQUE_NAME(lck1), UNIQUE_NAME(lck2)); \
    /*{ auto & t = *UNIQUE_NAME(lck1).mutex(); LockMark(t); } \
    { auto & t = *UNIQUE_NAME(lck2).mutex(); LockMark(t); } */ \
    auto const state = UNIQUE_NAME(cvstate)->getNodeUnsafe(); \
    auto const config = UNIQUE_NAME(cvconf)->getNodeUnsafe() \

define getStateConfigWithRRLock ¶

#define getStateConfigWithRRLock(
    state,
    config
)
    RT_TRY(uCVDictRoot UNIQUE_NAME(cvstate), getStateDict()); \
    RT_TRY2(uCVDictRoot UNIQUE_NAME(cvconf), getConfigDict()); \
    auto UNIQUE_NAME(lck1) = UNIQUE_NAME(cvstate)->getReadLockDefer(); \
    auto UNIQUE_NAME(lck2) = UNIQUE_NAME(cvconf)->getReadLockDefer(); \
    std::lock(UNIQUE_NAME(lck1), UNIQUE_NAME(lck2)); \
    /*{ auto & t = *UNIQUE_NAME(lck1).mutex(); LockMark(t); } \
    { auto & t = *UNIQUE_NAME(lck2).mutex(); LockMark(t); } */ \
    auto const state = UNIQUE_NAME(cvstate)->getNodeUnsafe(); \
    auto const config = UNIQUE_NAME(cvconf)->getNodeUnsafe() \