SH.h

Go to the documentation of this file.

#ifndef MN_STREAM_HANDLER_H
#define MN_STREAM_HANDLER_H

#include <sys/types.h>

#include "MNMutex.h"
#include "MNAttr.h"
#include "MNdictionary.h"
#include "MNSelector.h"
#include "dictionary.h"
#include "SHReturnCodes.h"
#include "SHStates.h"
#include "SHEndpoint.h"
#include "SHAttr.h"
#include "SHStatus.h"
#include "SHReport.h"
#include "var_type.h"

class SHGraphManager;

namespace SH
{

/**********************************************************************/
/* Base                                                               */
/**********************************************************************/

class Base
    : public Status
    , public AttributeStore
{
public:
    Base( SHGraphManager* mgr, u_int32_t runtimeId, MNSelector& sel );

    virtual ~Base();

    SHGraphManager* mgr();

    MNSelector& mainSelector();

    virtual SH_RC initSH();

    virtual SH_RC uninitSH();

    virtual SH_RC startStreaming();

    virtual SH_RC stopStreaming();

    virtual u_int16 get_rtp_seq();
    virtual u_int32 get_rtp_time(); 

    virtual SH_RC changePos( u_int64 bytepos );

private:

    Base( const Base& );

    Base& operator=( const Base& );

    /******************************************************************/
    /* sending reports through the system, provided for the endpoints */
    /******************************************************************/
protected:
    friend class Endpoint;
    friend class SinkEndpoint;
    friend class SourceEndpoint;

public:
    enum Direction
    {
        ReportUpstream,
        ReportDownstream
    };

protected:
    virtual void pushReport( ReportPtr report, Direction d );

    /******************************************************************/
    /* SH::SHSide                                                     */
    /******************************************************************/
public:
    class SHSide
    {
    protected:
        friend class Base;

        class EndpointTable
            : public MNdictionary<Endpoint*,Endpoint*>
        {
        public:
            virtual int compare( Endpoint* const& l,
                                 Endpoint* const& r ) const;
        };

        SHSide();

        ~SHSide();

        SH_RC validateUnconnected( Endpoint* dp );

        SH_RC connected( Endpoint* dp );

    private:
        MNMutex _instantiation_lock;

        size_t _count;


        EndpointTable _unconnected;

        EndpointTable _connected;
    };

    bool match( Base* downstream );
    bool match( SourceEndpoint* ep, Base* otherSH, SinkEndpoint* otherEP );

public:
    // Endpoint* createSourceEndpoint( EndpointSpec* dp );
    // Endpoint* createSinkEndpoint( EndpointSpec* dp );

    SH_RC connectSourceEndpoint( Endpoint* ep, Base* otherSH, Endpoint* otherEP );
    SH_RC connectSinkEndpoint( Endpoint* ep, Base* otherSH, Endpoint* otherEP ) ;

    SH_RC releaseSourceEndpoint( Endpoint* ep );
    SH_RC releaseSinkEndpoint( Endpoint* ep );

private:
    SHGraphManager* _manager;

    const u_int32_t _runtime_id;

    MNSelector& _main_selector;

    State           _state;

    bool            _invalid;

    SHSide          _sink_side;

    SHSide          _source_side;

protected:
    inline u_int32_t runtimeId() const { return _runtime_id; };
};

}; // namespace SH


#endif /* MN_STREAM_HANDLER_H */

---