legacy_filter.h

Go to the documentation of this file.

 
#ifndef _ADTF_ADTF2_LEGACY_FILTER_HEADER_
#define _ADTF_ADTF2_LEGACY_FILTER_HEADER_
 
#ifdef GetObject
#undef GetObject
#endif
 
namespace adtf
{
namespace adtf2
{
namespace ant
{
 
class cLegacyInputPin:
        public adtf::streaming::ant::sample_reader<adtf::streaming::ant::cDynamicSampleReaderQueue, false>
{
    public:
        tResult Create(const char* strName,
                       const ucom::iobject_ptr<const adtf::streaming::IStreamType>& pStreamType)
        {
            SetName(strName);
            return SetType(pStreamType);
        }
 
        tResult Create(const char* strName,
                       const ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType)
        {
            adtf::ucom::object_ptr<const adtf::streaming::IStreamType> pConstHelper = pStreamType;
            return Create(strName, pConstHelper);
        }
};
 
class cLegacyOutputPin: public adtf::streaming::ant::cSampleWriter
{
    private:
        bool m_bManualTriggerRequired = false;
 
    public:
        tResult Create(const char* strName,
                       const ucom::iobject_ptr<const adtf::streaming::IStreamType>& pStreamType)
        {
            SetName(strName);
            return SetType(pStreamType);
        }
 
        tResult Create(const char* strName,
                       const ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType)
        {
            adtf::ucom::object_ptr<const adtf::streaming::IStreamType> pConstHelper = pStreamType;
            return Create(strName, pConstHelper);
        }
 
        void SetManualTriggerRequired(bool bManualTriggerRequired)
        {
            m_bManualTriggerRequired = bManualTriggerRequired;
        }
 
        tResult Transmit(const ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
        {
            RETURN_IF_FAILED(adtf::streaming::ant::cSampleWriter::Transmit(pSample));
 
            if (m_bManualTriggerRequired)
            {
                RETURN_IF_FAILED(ManualTrigger());
            }
 
            RETURN_NOERROR;
        }
};
 
class cKernelAndClockHelper
{
    protected:
        adtf::ucom::object_ptr<adtf::services::IReferenceClock> _clock;
        adtf::ucom::object_ptr<adtf::services::IKernel> _kernel;
 
    protected:
        cKernelAndClockHelper()
        {
            _runtime->GetObject(_clock);
            _runtime->GetObject(_kernel);
        }
};
 
template<typename Child>
class cConfigurationHelper
{
    protected:
        void SetPropertyBool(const char* strName, bool bValue)
        {
            adtf::base::set_property(*static_cast<Child*>(this), strName, bValue);
        }
 
        void SetPropertyInt(const char* strName, int nValue)
        {
            adtf::base::set_property(*static_cast<Child*>(this), strName, nValue);
        }
 
        void SetPropertyFloat(const char* strName, double fValue)
        {
            adtf::base::set_property(*static_cast<Child*>(this), strName, fValue);
        }
 
        void SetPropertyStr(const char* strName, const char* strValue)
        {
            adtf::base::set_property(*static_cast<Child*>(this), strName, strValue);
        }
 
        bool GetPropertyBool(const char* strName, bool bDefault = false)
        {
            return adtf::base::get_property<bool>(*static_cast<Child*>(this), strName, bDefault);
        }
 
        int GetPropertyInt(const char* strName, int nDefault = 0)
        {
            return adtf::base::get_property<int>(*static_cast<Child*>(this), strName, nDefault);
        }
 
        double GetPropertyFloat(const char* strName, double fDefault = 0.0)
        {
            return adtf::base::get_property<double>(*static_cast<Child*>(this), strName,
                                                      fDefault);
        }
 
        adtf_util::cString GetPropertyStr(const tChar* strName, const tChar* strDefault = "")
        {
            return adtf::base::get_property<adtf_util::cString>(*static_cast<Child*>(this),
                                                                strName, strDefault);
        }
};
 
class cLegacyPinEvents
{
    protected:
        virtual tResult OnSampleReceived(cLegacyInputPin* /* pPin */,
            const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& /* pSample */)
        {
            RETURN_NOERROR;
        }
 
        virtual tResult OnTypeChanged(cLegacyInputPin* pPin,
            const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pType)
        {
            // by default we do the same that the reader would do.
            adtf::ucom::object_ptr<const adtf::streaming::IStreamType> pCurrentType;
            RETURN_IF_FAILED(pPin->GetType(pCurrentType));
            adtf::ucom::object_ptr<const adtf::streaming::IStreamMetaType> pMetaType;
            RETURN_IF_FAILED(pCurrentType->GetMetaType(pMetaType));
            return pMetaType->IsCompatible(*pType.Get(), *pCurrentType.Get());
        }
};
 
class cLegacyStateHandler
{
    public:
        enum tInitStage
        {
            StageFirst = 0,
            StageNormal = 1,
            StageGraphReady = 2,
        };
 
    protected:
        virtual tResult Init(tInitStage /* eStage */)
        {
            RETURN_NOERROR;
        }
 
        virtual tResult Start()
        {
            RETURN_NOERROR;
        }
 
        virtual tResult Stop()
        {
            RETURN_NOERROR;
        }
 
        virtual tResult Shutdown(tInitStage /* eStage */)
        {
            RETURN_NOERROR;
        }
};
 
class cLegacyFilter:
    public adtf::filter::ant::cTriggerFunction,
    public cKernelAndClockHelper,
    public cConfigurationHelper<cLegacyFilter>,
    public cLegacyPinEvents,
    public cLegacyStateHandler
{
    public:
        tResult Process(tTimeStamp /* tmTimeOfTrigger */) override
        {
            bool bSamplesFound;
            do
            {
                bSamplesFound = false;
                for (auto& pReader: m_vecOfReaders)
                {
                    adtf::ucom::object_ptr<const adtf::streaming::ISample> pSample;
                    if (IS_OK(pReader->GetNextSample(pSample)))
                    {
                        RETURN_IF_FAILED(OnSampleReceived(static_cast<cLegacyInputPin*>(pReader),
                                                          pSample));
                        bSamplesFound = true;
                    }
                }
            }
            while (bSamplesFound);
 
            RETURN_NOERROR;
        }
 
        tResult ConnectReadersAndWriters(adtf::filter::ant::cFilter& oFilter) override
        {
            for (auto& itReader : m_vecOfReaders)
            {
                adtf_util::cString strNameOfReader;
                itReader->GetName(adtf_string_intf(strNameOfReader));
                RETURN_IF_FAILED(filter_create_pin(oFilter, *itReader));
                RETURN_IF_FAILED(oFilter.ConfigureDataInTrigger(m_strName, strNameOfReader));
            }
            for (auto& itWriter : m_vecOfWriters)
            {
                adtf_util::cString strNameOfWriter;
                itWriter->GetName(adtf_string_intf(strNameOfWriter));
                RETURN_IF_FAILED(filter_create_pin(oFilter, *itWriter));
                RETURN_IF_FAILED(oFilter.ConfigureDataOutTrigger(m_strName, strNameOfWriter));
            }
            RETURN_NOERROR;
        }
 
    protected:
        tResult RegisterPin(cLegacyInputPin& oInput)
        {
            oInput.SetAcceptTypeCallback(
            [&](const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pStreamType)
            {
                return OnTypeChanged(&oInput, pStreamType);
            });
            return Register(oInput);
        }
 
        tResult RegisterPin(cLegacyOutputPin& oOutput)
        {
            return Register(oOutput);
        }
 
        adtf_util::cString OIGetInstanceName()
        {
            adtf_util::cString strName;
            GetName(adtf_string_intf(strName));
            return strName;
        }
};
 
template<typename TriggerFunctionImpl>
class legacy_filter : public adtf::filter::ant::cFilter
{
    private:
        legacy_filter(const legacy_filter&) = delete;
        legacy_filter(legacy_filter&&) = delete;
        legacy_filter& operator=(const legacy_filter&) = delete;
        legacy_filter& operator=(legacy_filter&&) = delete;
 
        TriggerFunctionImpl m_oTriggerFunc;
 
    protected:
        legacy_filter()
        {
            adtf_util::cString strTriggerFuncName;
            m_oTriggerFunc.GetName(adtf_string_intf(strTriggerFuncName));
            if (strTriggerFuncName.IsEmpty())
            {
                strTriggerFuncName = "trigger";
                m_oTriggerFunc.SetName(strTriggerFuncName);
            }
            m_oTriggerFunc.SetFilter(*this);
        }
 
        tResult Init(tInitStage eStage) override
        {
            RETURN_IF_FAILED(cFilter::Init(eStage));
            if (eStage == tInitStage::StageFirst)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Init(cLegacyStateHandler::StageFirst));
 
                adtf_util::cString strTriggerFuncName;
                m_oTriggerFunc.GetName(adtf_string_intf(strTriggerFuncName));
                RETURN_IF_FAILED(RegisterRunner(strTriggerFuncName, m_oTriggerFunc));
                RETURN_IF_FAILED(m_oTriggerFunc.ConnectReadersAndWriters(*this));
                RETURN_IF_FAILED(m_oTriggerFunc.Configure());
            }
            else if (eStage == tInitStage::StageNormal)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Init(cLegacyStateHandler::StageNormal));
            }
            else if(eStage == tInitStage::StageGraphReady)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Init(cLegacyStateHandler::StageGraphReady));
            }
            RETURN_NOERROR;
        }
 
        tResult Start() override
        {
            return m_oTriggerFunc.Start();
        }
 
        tResult Stop() override
        {
            return m_oTriggerFunc.Stop();
        }
 
        tResult Shutdown(tInitStage eStage) override
        {
            if (eStage == tInitStage::StageFirst)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Shutdown(cLegacyStateHandler::StageFirst));
            }
            else if(eStage == tInitStage::StageNormal)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Shutdown(cLegacyStateHandler::StageNormal));
            }
            else if(eStage == tInitStage::StageGraphReady)
            {
                RETURN_IF_FAILED(m_oTriggerFunc.Shutdown(cLegacyStateHandler::StageGraphReady));
            }
 
            return cFilter::Shutdown(eStage);
        }
};
 
}
 
using ant::cLegacyInputPin;
using ant::cLegacyOutputPin;
using ant::cLegacyFilter;
 
}
}
 
#define __sample_read_lock(__sample, __type, __variable) \
    adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer> __variable##Buffer; \
    RETURN_IF_FAILED(__sample->Lock(__variable##Buffer)); \
    const __type* __variable = reinterpret_cast<const __type*>(__variable##Buffer->GetPtr());
 
#define __sample_write_lock(__sample, __type, __variable) \
    adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer> __variable##Buffer; \
    RETURN_IF_FAILED(__sample->WriteLock(__variable##Buffer, sizeof(__type))); \
    __type* __variable = reinterpret_cast<__type*>(__variable##Buffer->GetPtr());
 
#define ADTF_LEGACY_FILTER_NAME(_class_identifier_, \
                                _class_name_, \
                                _legacyfilterclass_, \
                                _triggerfunction_) \
class _legacyfilterclass_ : public adtf::adtf2::ant::legacy_filter<_triggerfunction_> \
{ \
    public:\
        ADTF_CLASS_ID_NAME(_legacyfilterclass_, _class_identifier_, _class_name_); \
    public: \
        _legacyfilterclass_() = default; \
        virtual ~_legacyfilterclass_() = default; \
};
 
#define ADTF_LEGACY_FILTER_PLUGIN(_class_identifier_, \
                                  _class_name_,\
                                  _triggerfunction_)\
    ADTF_LEGACY_FILTER_NAME(_class_identifier_,\
                            _class_name_,\
                            _triggerfunction_##filter,\
                            _triggerfunction_)\
    ADTF_PLUGIN(_class_name_ " Plugin", \
                _triggerfunction_##filter);
 
#endif