player_intf.h

Go to the documentation of this file.

 
#pragma once
 
#include <adtf_base.h>
#include <adtf_ucom3.h>
 
#include <map>
 
#ifdef WIN32
#undef GetObject
#undef GetCurrentTime
#endif
 
namespace adtf
{
namespace services
{
namespace ant
{
 
 
 
class IPlayer : public adtf::ucom::ant::IObject
{
    public:
        ADTF_IID(IPlayer, "player.ant.services.adtf.iid");
 
    public:
        enum tState : uint32_t
        {
            Closed       = 0,
            Paused       = 1,
            Streaming    = 2,
        };
 
        struct tEvent
        {
            enum tEventIds: uint32_t
            {
                StartedPlaybackOfFile = 0,
 
                EndOfStreams = 1,
 
                MarkerReached = 2,
            };
 
            uint32_t nEventId;
            const void* pEventData;
            size_t nEventDataSize;
        };
 
        class IListStreamCallback
        {
            public:
                virtual tResult HandleStream(uint16_t ui16StreamId, const char* strStreamName) = 0;
        };
 
        virtual tResult Open(const char* strFileNames, bool bLoadReferencedFiles) = 0;
        virtual tResult Close() = 0;
 
        virtual tResult GetTimeRange(tTimeStamp& tmFirstItem, tTimeStamp& tmLastItem) const = 0;
 
        virtual uint64_t GetChunkCount() const = 0;
 
        virtual tResult GetCurrentFileNames(base::ant::IString&& strFileNames) const = 0;
 
        virtual tTimeStamp GetCurrentTime() const = 0;
 
        virtual IPlayer::tState GetCurrentState() const = 0;
 
        virtual tResult Play() = 0;
 
        virtual tResult Pause() = 0;
 
        virtual tResult Reset() = 0;
 
        virtual tResult SeekToTime(tTimeStamp tmTime) = 0;
 
        virtual tResult SeekToChunkIndex(uint64_t ui64ChunkIndex) = 0;
 
        virtual tResult SeekToStreamIndex(uint16_t ui16StreamId, uint64_t ui64StreamIndex) = 0;
 
        virtual tResult ListStreams(IListStreamCallback& oCallback) = 0;
};
 
inline tResult get_player(ucom::object_ptr<IPlayer>& pPlayer)
{
     return _runtime->GetObject(pPlayer);
}
 
class cPlayerStreams: public IPlayer::IListStreamCallback,
                      public std::map<adtf::util::cString, uint16_t>
{
    public:
        tResult HandleStream(uint16_t ui16StreamId, const char* strStreamName) override
        {
            insert({strStreamName, ui16StreamId});
            RETURN_NOERROR;
        }
};
 
}
 
namespace bat
{
 
class IPlayer : public adtf::services::ant::IPlayer
{
public:
    ADTF_IID(IPlayer, "player.bat.services.adtf.iid");
 
public:
 
    virtual tResult GetMarkers(adtf::base::ant::IString&& strMarkers) const = 0;
 
    virtual tResult ExtractAttachedFiles(const char* strAdtfDatFileNames,
        const char* strDestinationDirectory) = 0;
};
 
inline tResult get_player(ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
 
}
 
namespace elasto
{
 
class IPlayer : public adtf::services::bat::IPlayer
{
public:
    ADTF_IID(IPlayer, "player.elasto.remote.adtf");
 
public:
    enum class tLoopMode: uint32_t
    {
        DontLoop = 0,
        SeekToStart,
        ChangeRunlevel
    };
 
    enum class tStepDirection: uint32_t
    {
        Forward,
        Backward
    };
 
    enum class tStepItems: uint32_t
    {
        Any,
        Samples,
        StreamTypes,
        Triggers
    };
 
    virtual tResult SetLoopMode(const tLoopMode& eLoopMode) = 0;
 
    virtual tLoopMode GetLoopMode() const = 0;
 
    virtual tResult SetPlaybackSpeed(float fPlaybackSpeed) = 0;
 
    virtual float GetPlaybackSpeed() const = 0;
 
    virtual tResult Step(uint64_t nSteps, tStepDirection eDirection, tStepItems eItems, bool bWait) = 0;
 
};
 
inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
 
} // namespace elasto
 
namespace quiet 
{
class IPlayer : public adtf::services::elasto::IPlayer
{
public:
    ADTF_IID(IPlayer, "player.quiet.services.adtf.iid");
    
    using elasto::IPlayer::Open;
    virtual tResult Open(const char* strFilenames,
                         bool bLoadReferencedFiles,
                         const char* strReaderId,
                         const adtf::base::ant::IProperties* pReaderProperties = nullptr) = 0;
 
    virtual bool IsSeekable() const = 0;
};
 
inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
 
}
 
using quiet::IPlayer;
using quiet::get_player;
using ant::cPlayerStreams;
 
} // namespace services
} // namespace adtf