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 section_playback_input maps it to the StreamingGraph State.
 * 
 * @see    @ref sec_streaming_graph "Streaming Graph", @ref section_playback_input
 * 
 */
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,
        };
        enum tState : uint32_t {…};

        struct tEvent
        {
            enum tEventIds: uint32_t
            {
                StartedPlaybackOfFile = 0,

                EndOfStreams = 1,

                MarkerReached = 2,
            };
            enum tEventIds: uint32_t {…};

            uint32_t nEventId;
            const void* pEventData;
            size_t nEventDataSize;
        };
        struct tEvent {…};

        class IListStreamCallback
        {
            public:
                virtual tResult HandleStream(uint16_t ui16StreamId, const char* strStreamName) = 0;
        };
        class IListStreamCallback {…};

        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;
};
class IPlayer : public adtf::ucom::ant::IObject {…};

inline tResult get_player(ucom::object_ptr<IPlayer>& pPlayer)
{
     return _runtime->GetObject(pPlayer);
}
inline tResult get_player(ucom::object_ptr<IPlayer>& 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;
        }
        tResult HandleStream(uint16_t ui16StreamId, const char* strStreamName) override {…}
};
class cPlayerStreams: public IPlayer::IListStreamCallback, {…};
 
}
 
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;
};
class IPlayer : public adtf::services::ant::IPlayer {…};

inline tResult get_player(ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
inline tResult get_player(ucom::object_ptr<IPlayer>& 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 tLoopMode: uint32_t {…};
 
    enum class tStepDirection: uint32_t
    {
        Forward,
        Backward
    };
    enum class tStepDirection: uint32_t {…};
 
    enum class tStepItems: uint32_t
    {
        Any,
        Samples,
        StreamTypes,
        Triggers
    };
    enum class tStepItems: uint32_t {…};

    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;
 
};
class IPlayer : public adtf::services::bat::IPlayer {…};

inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer) {…}
 
} // namespace elasto
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;
};
class IPlayer : public adtf::services::elasto::IPlayer {…};

inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer)
{
    return _runtime->GetObject(pPlayer);
}
inline tResult get_player(adtf::ucom::object_ptr<IPlayer>& pPlayer) {…}
 
}
 
using quiet::IPlayer;
using quiet::get_player;
using ant::cPlayerStreams;
 
} // namespace services
} // namespace adtf