samplestream.h

Go to the documentation of this file.

#pragma once
#include "samplestream_intf.h"
#include "sampleinstream_intf.h"
#include "sampleoutstream_intf.h"
#include "streamtype.h"
#include "samplestream_statistics_intf.h"
#include "samplestreamaccess_intf.h"
#include "triggerpipe_intf.h"
#include "triggerpipe.h"
#include "streamingrequests_intf.h"
 
#include <adtfbase/adtf_base.h>
#include <adtfucom3/adtf_ucom3.h>
 
#include <memory>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
namespace detail
{
class cSampleStreamBase :
    public adtf::base::ant::runnable<adtf::base::IRunnable::RUN_TRIGGER>
{
    A_UTILS_D(cSampleStreamBase)
 
    using base_type = adtf::base::ant::runnable<adtf::base::IRunnable::RUN_TRIGGER>;
 
protected:
    cSampleStreamBase(const cSampleStreamBase&) = delete;
    cSampleStreamBase(cSampleStreamBase&&) = delete;
    cSampleStreamBase& operator=(const cSampleStreamBase&) = delete;
    cSampleStreamBase& operator=(cSampleStreamBase&&) = delete;
 
public:
    cSampleStreamBase();
    virtual ~cSampleStreamBase() override;

    tResult GetStreamError();
 
public:
    tResult Open(const char* strName,
                 adtf::ucom::ant::iobject_ptr<ISampleInStream>& pInStream,
                 const adtf::ucom::ant::iobject_ptr<const IStreamType>& pInitialAcceptedStreamType,
                 ISampleStream::IPushReadEventSink*& pPushEventSink,
                 ISampleStreamAccess::tMode ui32Mode,
                 size_t szQueueSize,
                 adtf::ucom::ant::IObject* pParent);
    tResult Open(const char* strName,
                 adtf::ucom::ant::iobject_ptr<ISampleOutStream>& pOutStream,
                 ISampleStreamAccess::tMode ui32Mode,
                 size_t szQueueSize,
                 adtf::ucom::ant::IObject* pParent);

    tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const;

    tTimeStamp GetTime() const;
    tResult SetStreamError(const tResult& oError);
    tResult AttachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo);
    tResult DetachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo);

    tResult SetFullName(const char* strName);

    tResult RunTrigger(tTimeStamp tmActivationTime);

    tResult GetInternalBindingProxy(ucom::ant::iobject_ptr<ant::IBindingProxy>& pBindingProxy);

    void SetSubStreamFilter(const char* strSubStream);

    uint64_t GetItemCount();

    void BlockSampleStreaming(bool bBlock);

    bool IsSampleStreamingBlocked() const;

    ISampleStreamStatistics::tSampleStreamStatistic GetStatistics();

    void EnableSampleSizeStatistics(bool bEnable);

    void ResetStatistics();

    void LogInputTrigger(tTimeStamp tmTrigger);

    void LogOutputTrigger(tTimeStamp tmTrigger);
};
} // namespace detail

template<typename INTERFACE = ISampleStream>
class sample_stream : public trigger_pipe_item<ant::INamedGraphObject, ISampleStream, INTERFACE>
{
    using base_type = trigger_pipe_item<ant::INamedGraphObject, ISampleStream, INTERFACE>;
 
protected:
    sample_stream(sample_stream&&) = delete;
    sample_stream(const sample_stream&) = delete;
    sample_stream& operator=(sample_stream&&) = delete;
    sample_stream& operator=(const sample_stream&) = delete;
 
public:
    sample_stream()
    {
        base_type::SetRunnable(static_cast<base::ant::IRunnable&>(m_oBase));
    }
    sample_stream(const char* strName): sample_stream()
    {
        SetName(strName);
    }
    ~sample_stream() = default;
 
    tResult SetName(const char* strName) override
    {
        RETURN_IF_FAILED(base_type::SetName(strName));
        return m_oBase.SetFullName(strName);
    }
 
    tResult SetParent(const ucom::ant::IObject* oParentObject) override
    {
        RETURN_IF_FAILED(base_type::SetParent(oParentObject));
        return m_oBase.SetFullName(get_named_graph_object_full_name(*this));
    }
 
    tResult Open(const char* strName,
                 adtf::ucom::ant::iobject_ptr<ISampleInStream>& pInStream,
                 const adtf::ucom::ant::iobject_ptr<const IStreamType>& pInitialAcceptedStreamType,
                 ISampleStream::IPushReadEventSink*& pPushEventSink,
                 ISampleStreamAccess::tMode ui32Mode,
                 size_t szQueueSize) override
    {
        return m_oBase.Open(strName, pInStream, pInitialAcceptedStreamType, pPushEventSink, ui32Mode, szQueueSize,
                            adtf::ucom::ant::ucom_cast<adtf::ucom::ant::IObject*>(this));
    }
 
    tResult Open(const char* strName,
                 adtf::ucom::ant::iobject_ptr<ISampleOutStream>& pOutStream,
                 ISampleStreamAccess::tMode ui32Mode,
                 size_t szQueueSize) override
    {
        return m_oBase.Open(strName, pOutStream, ui32Mode, szQueueSize,
                            adtf::ucom::ant::ucom_cast<adtf::ucom::ant::IObject*>(this));
    }
 
    tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const override
    {
        return m_oBase.GetType(pStreamType);
    }

    tTimeStamp GetTime() const override
    {
        return m_oBase.GetTime();
    }

    tResult SetStreamError(const tResult& oError) override
    {
        return m_oBase.SetStreamError(oError);
    }

    tResult AttachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo) override
    {
        return m_oBase.AttachRouting(pSampleStreamTo);
    }

    tResult DetachRouting(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStreamTo) override
    {
        return m_oBase.DetachRouting(pSampleStreamTo);
    }
 
private:
    detail::cSampleStreamBase m_oBase;
};

class cSampleStream : public sample_stream<ISampleStream>
{
    A_UTILS_D(cSampleStream)
 
public:
    ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
protected:
    cSampleStream(const cSampleStream&) = delete;
    cSampleStream(cSampleStream&&) = delete;
    cSampleStream& operator=(const cSampleStream&) = delete;
    cSampleStream& operator=(cSampleStream&&) = delete;
 
public:
    cSampleStream() = default;
    cSampleStream(const char* strName)
    {
        sample_stream::SetName(strName);
    }

    virtual ~cSampleStream() = default;
};
 
} // namespace ant
 
namespace flash
{
 
class cSampleStream :
    public trigger_pipe_item<ant::INamedGraphObject, hollow::IInternalBindingProxy, ant::ISampleStream>
{
public:
    ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
public:
    cSampleStream();
    cSampleStream(const char* strName);
 
    ~cSampleStream() 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;
 
    tResult GetInternalBindingProxy(ucom::ant::iobject_ptr<ant::IBindingProxy>& pBindingProxy) override;
    void SetSubStreamFilter(const char* strSubStream);
    void SetForwardAllTriggers(bool bForwardAll);
 
public:
    tResult SetName(const char* strName);
    tResult SetParent(const ucom::ant::IObject* oParentObject);
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace flash
 
namespace quiet
{
 
using flash::cSampleStream;
 
} // namespace quiet
 
namespace vision
{
 
class cSampleStream : public ucom::catwo::object<quiet::cSampleStream, IBlockableSampleStream>
{
public:
    ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
public:
    cSampleStream();
    cSampleStream(const char* strName);
 
    ~cSampleStream() override;
 
    void BlockSampleStreaming(bool bBlock) override;
    bool IsSampleStreamingBlocked() const override;
};
 
} // namespace vision
 
namespace wolverine
{
 
class cSampleStream : public ucom::catwo::object<vision::cSampleStream, ISampleStreamStatistics>
{
public:
    ADTF_CLASS_ID_NAME(cSampleStream, "sample_stream.streaming.adtf.cid", "Sample Stream");
 
public:
    cSampleStream();
    cSampleStream(const char* strName);
 
    ~cSampleStream() override;
 
public: // implements ISampleStreamStatistics
    tSampleStreamStatistic GetStatistics() override;
    void EnableSampleSizeStatistics(bool bEnable) override;
    void ResetStatistics() override;
};
 
} // namespace wolverine

using wolverine::cSampleStream;
using ant::sample_stream;
 
} // namespace streaming
} // namespace adtf