filtergraphport.h

Go to the documentation of this file.

#pragma once
 
#include "triggerpipe.h"
#include "runner_intf.h"
#include "pin_intf.h"
#include "inpin_intf.h"
#include "outpin_intf.h"
#include "filtergraphport_intf.h"
#include "interface_binding_client_intf.h"
 
#include <adtfbase/runnable_intf.h>
 
#include <algorithm>
#include <memory>
#include <type_traits>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
namespace detail
{
template<typename T, typename U = T>
struct port_router
{
    struct tDestination
    {
        adtf::ucom::object_ptr<U> pTo;
        bool bTriggerForwarding = false;
    };

    adtf::ucom::object_ptr<T> m_pFrom;
    std::vector<tDestination> m_oTos;
    bool m_bTriggerForwardingFromParent = false;

    port_router() = default;
    ~port_router()
    {
        RemoveTos();
    }

    tResult ResetFrom(const adtf::ucom::ant::iobject_ptr<T>& pFrom)
    {
        if (m_pFrom.Get() == pFrom.Get())
        {
            // we do nothing ... already routing
            // or nullptr == nullptr
        }
        else
        {
            if (m_pFrom)
            {
                if (pFrom.Get())
                {
                    RETURN_ERROR_DESC(ERR_DEVICE_IN_USE,
                                      "This port is already connected to a sample stream / binding proxy.");
                }
 
                for (const auto& sTo : m_oTos)
                {
                    DisconnectRouting(m_pFrom, sTo);
                }
            }
            m_pFrom = pFrom;
            if (m_pFrom)
            {
                for (const auto& sTo : m_oTos)
                {
                    RETURN_IF_FAILED(ConnectRouting(m_pFrom, sTo));
                }
            }
        }
        RETURN_NOERROR;
    }

    tResult AddTo(const adtf::ucom::ant::iobject_ptr<U>& pTo)
    {
        if (FindTo(pTo) != m_oTos.end())
        {
            // we do nothing ... already forwarding
            // or nullptr == nullptr
        }
        else
        {
            if (pTo.Get())
            {
                tDestination sTo;
                sTo.pTo = pTo;
 
                if (m_pFrom)
                {
                    RETURN_IF_FAILED(ConnectRouting(m_pFrom, sTo));
                }
 
                m_oTos.push_back(sTo);
            }
        }
        RETURN_NOERROR;
    }
 
    void RemoveTos()
    {
        for (const auto& sTo : m_oTos)
        {
            DisconnectRouting(m_pFrom, sTo);
        }
 
        m_oTos.clear();
    }

    tResult ConnectRouting(const adtf::ucom::ant::iobject_ptr<T>& pFrom, const tDestination& sTo)
    {
        if (pFrom.Get() != nullptr && sTo.pTo.Get() != nullptr)
        {
            LOG_DETAIL("Attach routing '%s' -> '%s'", get_named_graph_object_full_name(*pFrom.Get()).GetPtr(),
                       get_named_graph_object_full_name(*sTo.pTo.Get()).GetPtr());
            RETURN_IF_FAILED(pFrom->AttachRouting(sTo.pTo));
 
            if (m_bTriggerForwardingFromParent && sTo.bTriggerForwarding)
            {
                RETURN_IF_FAILED(SetTriggerForwarding(pFrom, sTo.pTo, true));
            }
        }
 
        RETURN_NOERROR;
    }

    tResult DisconnectRouting(const adtf::ucom::ant::iobject_ptr<T>& pFrom, const tDestination& sTo)
    {
        if (pFrom.Get() != nullptr && sTo.pTo.Get() != nullptr)
        {
            if (m_bTriggerForwardingFromParent && sTo.bTriggerForwarding)
            {
                RETURN_IF_FAILED(SetTriggerForwarding(pFrom, sTo.pTo, false));
            }
 
            RETURN_IF_FAILED(pFrom->DetachRouting(sTo.pTo));
        }
 
        RETURN_NOERROR;
    }

    tResult SetTriggerForwardingFromParent(bool bForwarded)
    {
        if (m_bTriggerForwardingFromParent != bForwarded)
        {
            m_bTriggerForwardingFromParent = bForwarded;
            for (const auto& sTo : m_oTos)
            {
                if (sTo.bTriggerForwarding)
                {
                    RETURN_IF_FAILED(SetTriggerForwarding(m_pFrom, sTo.pTo, m_bTriggerForwardingFromParent));
                }
            }
        }
 
        RETURN_NOERROR;
    }

    tResult SetTriggerForwardingToChild(const adtf::ucom::ant::iobject_ptr<U>& pTo, bool bForwarded)
    {
        if (!pTo.Get())
        {
            // nothing was ever routed to, @see AddTo
            RETURN_NOERROR;
        }
 
        const auto itTo = FindTo(pTo);
        if (itTo == m_oTos.end())
        {
            if (bForwarded)
            {
                RETURN_ERROR_DESC(ERR_NOT_FOUND, "This port does not route to the given destination.");
            }
 
            // a disconnect tears the routing down before it gets here, so there is nothing left to undo
            RETURN_NOERROR;
        }
 
        if (itTo->bTriggerForwarding != bForwarded)
        {
            itTo->bTriggerForwarding = bForwarded;
            if (m_bTriggerForwardingFromParent)
            {
                RETURN_IF_FAILED(SetTriggerForwarding(m_pFrom, itTo->pTo, m_bTriggerForwardingFromParent));
            }
        }
 
        RETURN_NOERROR;
    }
 
private:
    typename std::vector<tDestination>::iterator FindTo(const adtf::ucom::ant::iobject_ptr<U>& pTo) noexcept
    {
        return std::find_if(m_oTos.begin(), m_oTos.end(), [&pTo](const tDestination& sTo) noexcept
        {
            return sTo.pTo.Get() == pTo.Get();
        });
    }

    static tResult SetTriggerForwarding(const adtf::ucom::ant::iobject_ptr<T>& pFrom,
                                     const adtf::ucom::ant::iobject_ptr<U>& pTo,
                                     bool bRoute)
    {
        if constexpr (std::is_base_of_v<ITriggerPipeSource, T> && std::is_base_of_v<ITriggerPipeItem, U>)
        {
            if (pFrom.Get() != nullptr && pTo.Get() != nullptr)
            {
                const auto pSubItem = adtf::ucom::ucom_object_ptr_cast<ITriggerPipeItem>(pTo);
                RETURN_IF_FAILED(bRoute ?
                                     pFrom->RegisterSubItem(pSubItem, ITriggerPipeSource::tPriority::Normal) :
                                     pFrom->UnregisterSubItem(pSubItem));
            }
        }
 
        RETURN_NOERROR;
    }
};
} // namespace detail

class cFilterGraphDataInPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IInPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataInPort>
{
private:
    detail::port_router<ISampleStream> m_oStreamRouter;
    std::atomic_bool m_bActive;
 
public:
    cFilterGraphDataInPort();
    cFilterGraphDataInPort(const char* strName);
    virtual ~cFilterGraphDataInPort() override;
 
public:
    tResult InnerConnect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
 
public:
    tResult SetTriggerForwardingFromParent(bool bForwarded) override;
    tResult SetTriggerForwardingToChild(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream,
                                bool bForwarded) override;
};

class cFilterGraphDataOutPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IOutPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataOutPort>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    detail::port_router<ISampleStream> m_oStreamRouter;
    std::atomic_bool m_bActive;
 
public:
    cFilterGraphDataOutPort();
    cFilterGraphDataOutPort(const char* strName);
    virtual ~cFilterGraphDataOutPort() override;
 
public:
    tResult InnerConnect(const iobject_ptr<ISampleStream>& pSampleStream);
    tResult InnerDisconnect();
 
public:
    tResult Connect(const iobject_ptr<ISampleStream>& pSampleStream) override;
 
public:
    tResult GetType(iobject_ptr<const IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(iobject_ptr<ISampleStream>& pSampleStream) const override;
 
public:
    tResult SetTriggerForwardingFromParent(bool bForwarded) override;
    tResult SetTriggerForwardingToChild(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream,
                                bool bForwarded) override;
};

class cFilterGraphServerPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingServer,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceServerPort>>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    detail::port_router<IBindingProxy> m_oProxyRouter;
 
public:
    cFilterGraphServerPort();
    cFilterGraphServerPort(const char* strName);
    virtual ~cFilterGraphServerPort() override;
 
public:
    tResult InnerBind(const iobject_ptr<IBindingProxy>& pSampleStream);
    tResult InnerUnbind();
 
public:
    tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy);
 
public:
    tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const;
    tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const;
    tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const;
    tResult Unbind();
};

class cFilterGraphClientPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingClient,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceClientPort>>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
private:
    adtf::ucom::object_ptr<IBindingClient> m_pClientRouter;
    adtf::ucom::object_ptr<IBindingProxy> m_pOuterProxy;
 
public:
    cFilterGraphClientPort();
    cFilterGraphClientPort(const char* strName);
    virtual ~cFilterGraphClientPort() override;
 
public:
    tResult InnerBind(const iobject_ptr<IBindingClient>& pClientForward) override;
    tResult InnerUnbind() override;
 
public:
    tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy) override;
 
public:
    tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const override;
    tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const override;
    tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const override;
    tResult Unbind() override;
};

class cFilterGraphRunnerPort :
    public trigger_pipe_item<INamedGraphObject, IFilterGraphPort, IRunner, IFilterGraphRunnerPort>
{
public:
    template<typename T>
    using iobject_ptr = adtf::ucom::ant::iobject_ptr<T>;
 
public:
    cFilterGraphRunnerPort();
    cFilterGraphRunnerPort(const char* strName);
    virtual ~cFilterGraphRunnerPort() override;
 
public:
    tResult InnerRegisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
    tResult InnerUnregisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
};
 
} // namespace ant
 
namespace flash
{
 
using ant::cFilterGraphRunnerPort;
 
class cFilterGraphDataInPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IInPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataInPort>
{
public:
    cFilterGraphDataInPort();
    cFilterGraphDataInPort(const char* strName);
    ~cFilterGraphDataInPort() override;
 
public:
    tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
 
public:
    tResult SetTriggerForwardingFromParent(bool bForwarded) override;
    tResult SetTriggerForwardingToChild(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream,
                                bool bForwarded) override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
class cFilterGraphDataOutPort :
    public trigger_pipe_item<INamedGraphObject,
                             IPin,
                             IOutPin,
                             IFilterGraphPort,
                             IFilterGraphDataPort,
                             IFilterGraphDataOutPort>
{
public:
    cFilterGraphDataOutPort();
    cFilterGraphDataOutPort(const char* strName);
    ~cFilterGraphDataOutPort() override;
 
public:
    tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
    tResult InnerDisconnect() override;
 
public:
    tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
 
    bool IsConnected() const override;
    tResult SetActive() override;
    tResult SetInactive() override;
 
    tResult Disconnect() override;
    tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
 
public:
    tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
 
public:
    tResult SetTriggerForwardingFromParent(bool bForwarded) override;
    tResult SetTriggerForwardingToChild(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream,
                                bool bForwarded) override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace flash
 
namespace hollow
{

class cFilterGraphClientPort :
    public ucom::catwo::object<IBindingObject,
                               IBindingClient,
                               IFilterGraphPort,
                               IFilterGraphInterfacePort,
                               named_graph_object<IFilterGraphInterfaceClientPort>>
{
public:
    cFilterGraphClientPort();
    cFilterGraphClientPort(const char* strName);
    virtual ~cFilterGraphClientPort() override;
 
public:
    tResult InnerBind(const ucom::ant::iobject_ptr<IBindingClient>& pClientForward) override;
    tResult InnerUnbind() override;
 
public:
    tResult Bind(const ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) override;
 
public:
    tResult GetBindingType(ucom::ant::iobject_ptr<const IBindingType>& pBindingType) const override;
    tResult GetServerObject(ucom::ant::iobject_ptr<IObject>& pServerObject) const override;
    tResult GetBindingProxy(ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) const override;
    tResult Unbind() override;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};
 
} // namespace hollow
 
namespace quiet
{

using flash::cFilterGraphRunnerPort;

using flash::cFilterGraphDataInPort;

using flash::cFilterGraphDataOutPort;
 
} // namespace quiet

using quiet::cFilterGraphRunnerPort;
using quiet::cFilterGraphDataInPort;
using quiet::cFilterGraphDataOutPort;
using ant::cFilterGraphServerPort;
using hollow::cFilterGraphClientPort;
} // namespace streaming
} // namespace adtf