samplestreamoutport.h

Go to the documentation of this file.

 
#pragma once
 
#include "samplestream.h"
#include "streaming_graph_intf.h"
#include "samplestreamport_intf.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{
    class cSampleStreamOutPort :
        public ucom::catwo::object<IStreamingPort,
                                   IStreamingOutPort,
                                   sample_stream<ISampleStreamOutPort>>
    {
        public: 
            ADTF_CLASS_ID_NAME(cSampleStreamOutPort,
                               "default_sample_stream_out_port.streaming.adtf.cid",
                               "Sample Stream Outport");
 
        protected: 
            cSampleStreamOutPort(const cSampleStreamOutPort&) = delete;
            cSampleStreamOutPort(cSampleStreamOutPort&&) = delete;
            cSampleStreamOutPort& operator=(const cSampleStreamOutPort&) = delete;
            cSampleStreamOutPort& operator=(cSampleStreamOutPort&&) = delete;
 
            cSampleStreamOutPort() = default;
        public: 
   
            cSampleStreamOutPort(const char* strName, const char* strPortID)
            {
                SetName(strName);
                m_strPortID = strPortID;
            }
            virtual ~cSampleStreamOutPort() = default;
 
    public:
        tResult GetPortID(adtf::base::ant::IString&& strID)
        {
            return strID.Set(m_strPortID);
        }
    private:
        adtf_util::cString m_strPortID;
    };
 
 
} //namespace ant
 
namespace flash
{
 
class cSampleStreamOutPort: public ucom::catwo::object<base::ant::IRunnable,
                                                       ant::ITriggerPipeSource,
                                                       ant::ITriggerPipeItem,
                                                       ant::INamedGraphObject,
                                                       ant::ISampleStream,
                                                       ant::IStreamingPort,
                                                       ant::IStreamingOutPort,
                                                       ant::ISampleStreamOutPort,
                                                       base::flash::IRunnable>
{
    public:
        cSampleStreamOutPort();
        cSampleStreamOutPort(const char* strName, const char* strPortId);        
 
    public:
        tResult Run(tTimeStamp tmTimeofActivation,
                    base::ant::IRunnable::tActivationType ui32ActivationType,
                    const void* pvUserData,
                    size_t nUserDataSize) override;
 
        tResult Run(base::flash::tNanoSeconds tmTimeofActivation,
                    base::ant::IRunnable::tActivationType ui32ActivationType,
                    const void* pvUserData,
                    size_t nUserDataSize) override;
 
    public:
        tResult RegisterSubItem(const ucom::ant::iobject_ptr<ant::ITriggerPipeItem>& pSubRun,
                                ant::ITriggerPipeSource::tPriority ui32Prio) override;
        tResult UnregisterSubItem(const ucom::ant::iobject_ptr<ant::ITriggerPipeItem>& pSubRun) override;
 
        tResult ChangePriority(const ucom::ant::iobject_ptr<ant::ITriggerPipeItem>& pSubRun,
                               ant::ITriggerPipeSource::tPriority ui32Prio) override;
        tResult GetSubItems(ucom::ant::iobject_enum<const ant::ITriggerPipeItem>& lstSubItems) const override;
 
    public:
        tResult GetName(base::ant::IString&& strName) const override;
        tResult SetName(const char* strName) override;
        tResult SetParent(const ucom::ant::IObject* oParentObject) override;
        tResult GetParent(const ucom::ant::IObject*& poParentObject) const override;
 
    public:
        tResult GetStreamError();
        tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
        tTimeStamp GetTime() const override;
        tResult SetStreamError(const tResult& oError) override;
        tResult AttachRouting(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStreamTo) override;
        tResult DetachRouting(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStreamTo) override;
        tResult Open(const char* strName,
                     ucom::ant::iobject_ptr<ant::ISampleInStream>& pInStream,
                     const ucom::ant::iobject_ptr<const ant::IStreamType>& pInitialAcceptedStreamType,
                     ant::ISampleStream::IPushReadEventSink*& pPushEventSink,
                     ant::ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override;
        tResult Open(const char* strName,
                     ucom::ant::iobject_ptr<ant::ISampleOutStream>& pOutStream,
                     ant::ISampleStreamAccess::tMode ui32Mode,
                     size_t szQueueSize) override;
    public:
        tResult GetPortID(adtf::base::ant::IString&& strID) override;
 
    protected:
        ~cSampleStreamOutPort() override;
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
}
 
namespace quiet
{
 
class cSampleStreamOutPort: public ucom::catwo::object<flash::cSampleStreamOutPort,
                                                       ITriggerPipeHierachy>
{
    public:
        cSampleStreamOutPort();
        cSampleStreamOutPort(const char* strName, const char* strPortId);
        ~cSampleStreamOutPort() override;
 
        ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
};
 
}
 
using quiet::cSampleStreamOutPort;
} //namespace streaming
} //namespace adtf