recorder_intf.h

Go to the documentation of this file.

 
#ifndef _ADTF_RECORDER_INTF_CLASS_HEADER_
#define _ADTF_RECORDER_INTF_CLASS_HEADER_
 
#include <adtf_base.h>
#include "recording_file_intf.h"
 
namespace adtf
{
namespace services
{
namespace ant
{
 
 
 
class IRecorder : public adtf::ucom::ant::IObject
{
    public:
        ADTF_IID(IRecorder, "recorder.ant.services.adtf.iid");
 
    public:
        enum tState : uint32_t
        {
            Closed = 0,
            Idle = 1,
            Queueing = 2,
            Recording = 3
        };
        
        virtual tResult Start(const char* strFileName) = 0;
        
        virtual tResult Stop(const char* strFileName) = 0;
 
        virtual tResult Split(const char* strFileName) = 0;
 
        virtual tResult GetTimeRange(tTimeStamp& tmFirstItem, tTimeStamp& tmLastItem) const = 0;
 
        virtual tResult GetCurrentFileName(adtf::base::ant::IString&& strFileName) const = 0;
 
        virtual IRecorder::tState GetCurrentState() const = 0;
 
 
};
 
#ifdef _ADTF_SYSTEMSDK_PACKAGE_HEADER_
template <typename RecorderInterface = IRecorder>
inline tResult get_recorders(adtf::ucom::object_list<RecorderInterface>& lstRecorders)
{
    adtf::ucom::object_list<RecorderInterface, ucom::ant::IObject> lstRecordersFound;
    // get the current session
    adtf::ucom::object_ptr<ISession> pSession;
    RETURN_IF_FAILED(get_session(pSession));
    // get the current streaming graph
    adtf::ucom::object_ptr<streaming::IStreamingGraph> pStreamingGraph;
    RETURN_IF_FAILED(pSession->GetCurrentStreamingGraph(pStreamingGraph));
    // search for FIRST !!! interface in streaming graph Multiple instances are possible
    RETURN_IF_FAILED(streaming::get_streaming_graph_objects(*pStreamingGraph, lstRecordersFound));
    adtf::ucom::object_ptr<streaming::IFilterGraph> pFilterGraph;
    if (IS_OK(pSession->GetCurrentFilterGraph(pFilterGraph)))
    {
        RETURN_IF_FAILED(streaming::get_filter_graph_objects(*pFilterGraph, lstRecordersFound))
    }
 
    for (auto it : lstRecordersFound)
    {
        lstRecorders.PushObject(it);
    }
    RETURN_NOERROR;
}
 
template <typename RecorderInterface = IRecorder>
inline tResult get_recorder(adtf::ucom::ant::object_ptr<RecorderInterface>& pRecorder)
{
     adtf::ucom::object_list<RecorderInterface> lstRecorders;
     RETURN_IF_FAILED(get_recorders(lstRecorders));
     if (lstRecorders.GetSize() > 0)
     {
         return pRecorder.Reset(*lstRecorders.begin());
     }
 
     RETURN_ERROR_DESC(ERR_NOT_FOUND, "No recorder found");
}
#endif // _ADTF_SYSTEMSDK_PACKAGE_HEADER_
 
}
 
namespace bat
{
 
class IRecorder : public ant::IRecorder
{
    public:
        ADTF_IID(IRecorder, "recorder.bat.services.adtf.iid");
 
        virtual tResult AddMarker(tTimeStamp tmTimeStamp, const char* strName = nullptr,
                                  const char* strAdditional = nullptr) = 0;
 
        virtual tResult DropHistory() = 0;
};
 
#ifdef _ADTF_SYSTEMSDK_PACKAGE_HEADER_
using ant::get_recorders;
using ant::get_recorder;
#endif // _ADTF_SYSTEMSDK_PACKAGE_HEADER_
 
}
 
namespace devil
{
 
class IRecorder: public bat::IRecorder
{
    public:
        ADTF_IID(IRecorder, "recorder.devil.services.adtf.iid");
 
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable : 4200)
#endif
        struct tEvent
        {
            enum tEventIds: uint32_t
            {
                PostFileClosed = 2,
                PostFileDiscarded = 3
            };
 
            uint64_t nEventDataSize;
            uint32_t nEventId;
            uint8_t aEventData[0];
        };
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
 
};
 
}
 
using devil::IRecorder;
 
#ifdef _ADTF_SYSTEMSDK_PACKAGE_HEADER_
using ant::get_recorder;
using ant::get_recorders;
#endif // _ADTF_SYSTEMSDK_PACKAGE_HEADER_
}
}
#endif