legacy_streaming_sink.h

Go to the documentation of this file.

 
#ifndef _ADTF_ADTF2_LEGACY_STREAMING_SINK_HEADER_
#define _ADTF_ADTF2_LEGACY_STREAMING_SINK_HEADER_
 
namespace adtf
{
namespace adtf2
{
namespace ant
{
 
typedef adtf::base::runnable<adtf::base::IRunnable::RUN_TRIGGER> trigger_runnable;
 
class cLegacyStreamingSink:
    public adtf::streaming::cSampleStreamingSink,
    public cKernelAndClockHelper,
    public cConfigurationHelper<cLegacyStreamingSink>,
    public cLegacyPinEvents,
    public cLegacyStateHandler,
    public trigger_runnable
{
    public:
        cLegacyStreamingSink():
            trigger_runnable(ADTF_RUN_FUNCTION(Trigger)),
            m_pRunner(adtf::ucom::make_object_ptr<cTriggerPipeItemHelper>(*this))
        {
        }
 
    protected:
        virtual tResult Construct()
        {
            RETURN_IF_FAILED(Init(cLegacyStateHandler::StageFirst));
            return Init(cLegacyStateHandler::StageNormal);
        }
 
        virtual tResult Destruct()
        {
            RETURN_IF_FAILED(Shutdown(cLegacyStateHandler::StageNormal));
            return Shutdown(cLegacyStateHandler::StageFirst);
        }
 
        virtual tResult Init()
        {
            return Init(cLegacyStateHandler::StageGraphReady);
        }
 
        virtual tResult Shutdown()
        {
            return Shutdown(cLegacyStateHandler::StageGraphReady);
        }
 
        virtual tResult StartStreaming()
        {
            return Start();
        }
 
        virtual tResult StopStreaming()
        {
            return Stop();
        }
 
    protected:
        // these methods are defined here as well in order to allow easy access via
        // cLegacyStreamingSource:: prefix.
 
        tResult Init(tInitStage /* eStage */) override
        {
            RETURN_NOERROR;
        }
 
        tResult Start() override
        {
            RETURN_NOERROR;
        }
 
        tResult Stop() override
        {
            RETURN_NOERROR;
        }
 
        tResult Shutdown(tInitStage /* eStage */) override
        {
            RETURN_NOERROR;
        }
 
    protected:
        tResult RegisterPin(cLegacyInputPin& oInput)
        {
            oInput.SetAcceptTypeCallback([&](const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pStreamType)
            {
                return OnTypeChanged(&oInput, pStreamType);
            });
 
            adtf_util::cString strNameOfReaderAndPin;
            RETURN_IF_FAILED(oInput.GetName(adtf_string_intf(strNameOfReaderAndPin)));
            auto pInPin = adtf::ucom::make_object_ptr<adtf::streaming::ant::cInPin>(strNameOfReaderAndPin);
            oInput.ResetPin(pInPin);
            adtf::ucom::object_ptr<adtf::streaming::IPin> pPin = pInPin;
 
            RETURN_IF_FAILED(pPin->RegisterSubItem(m_pRunner, adtf::streaming::ITriggerPipeSource::Normal));
            RETURN_IF_FAILED(cSampleStreamingSink::RegisterPin(pPin));
            m_oLegacyPins.push_back(&oInput);
            RETURN_NOERROR;
        }
 
        tResult Trigger(tTimeStamp /* tmTimeOfActivation */)
        {
            bool bSamplesFound;
            do
            {
                bSamplesFound = false;
                for (auto& pReader: m_oLegacyPins)
                {
                    adtf::ucom::object_ptr<const adtf::streaming::ISample> pSample;
                    if (IS_OK(pReader->GetNextSample(pSample)))
                    {
                        RETURN_IF_FAILED(OnSampleReceived(pReader,
                                                          pSample));
                        bSamplesFound = true;
                    }
                }
            }
            while (bSamplesFound);
 
            RETURN_NOERROR;
        }
 
    private:
        // we cannot make cLegacyStreamingSink a trigger pipe item itself,
        // as this would cause a reference loop between the pins and the sink
        class cTriggerPipeItemHelper:
            public streaming::trigger_pipe_item<adtf::streaming::ITriggerPipeItem>
        {
            public:
                cTriggerPipeItemHelper(cLegacyStreamingSink& oSink)
                {
                    SetRunnable(oSink);
                }
        };
 
    private:
        adtf::ucom::object_ptr<adtf::streaming::ITriggerPipeItem> m_pRunner;
        std::vector<cLegacyInputPin*> m_oLegacyPins;
 
 
};
 
}
 
using ant::cLegacyStreamingSink;
 
}
}
 
 
#endif