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
{

ucom::object_ptr<IPlayer> pPlayer;
// MIND: This call will only succeed if player is present and it will be called _AFTER_ the PlaybackService was
initialized! if (IS_OK(get_player(pPlayer))
{
    if (IS_OK(pPlayer->Open("c:/temp/my_test_file.adtfdat", true)))
    {
        pPlayer->Play();
    }
}

 
 * \endcode
 *
 * @remark Usually this Playback interface and the states of the Player does NOT depend on the Runlevel.
 *         Only the concrete implementation of the @ref page_player maps it to the StreamingGraph State.
 */
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,

            StateChangeEnd = 3,
        };

        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 ant
 
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 bat
 
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);
}
 
} // namespace quiet
 
using quiet::IPlayer;
using quiet::get_player;
using ant::cPlayerStreams;
 
} // namespace services
} // namespace adtf