sample_intf.h

Go to the documentation of this file.

#pragma once
#include "samplebuffer_intf.h"
#include "sampleinfo_intf.h"
#include "samplelog/samplelog_intf.h"
 
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/chrono.h>
#include <adtfbase/rawmemory_intf.h>
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
 

#define CID_ADTF_SAMPLE_POOL      "sample_pool.service.adtf.cid"
class ISample: public ucom::ant::IObject
{
    protected:
        ~ISample() = default;
 
    public:
        ADTF_IID(ISample, "sample.ant.streaming.adtf.iid");
 
 
    public:
        enum eFlags : uint32_t
        {
            SF_None = 0x0,

             SF_SyncPoint = 0x2,

              SF_AbsoluteTime = 0x4,

              SF_DataFromADTF1 = 0x8,

              SF_VideoKeyFrame = 0x10,

              SF_SampleLogEnabled = 0x40,
              SF_SampleLogPresent = 0x80,
              SF_SampleInfoPresent = 0x100,
              SF_AllowBufferSharing = 0x400,
        };
        enum eFlags : uint32_t {…};

        virtual tResult Lock(ucom::ant::iobject_ptr_shared_locked<const ISampleBuffer>& oSampleBuffer) const = 0;
 

        virtual tResult WriteLock(ucom::ant::iobject_ptr_locked<ISampleBuffer>& pSampleBuffer,
                                  size_t szPreAllocateSize) = 0;

        virtual tResult Set(const ISample& oSample) = 0;

        virtual tResult Get(ISample& oSample) const = 0;

        virtual tResult Reset() = 0;

        virtual uint32_t GetFlags() const = 0;

        virtual tResult SetFlags(uint32_t ui32Flags) = 0;

        ADTF3_DEPRECATED("Use adtf::streaming::flash::ISample::Set(adtf::base::flash::tNanoSeconds tmTimeStamp, const void* pData, size_t szSize, uint32_t ui32Flags=0) instead.")
        virtual tResult Set(tTimeStamp    tmTimeStamp,
                            const void*  pData,
                            size_t         szSize,
                            uint32_t       ui32Flags=0) = 0;
        virtual tResult GetSampleBufferFactory(ucom::ant::iobject_ptr<ISampleBufferFactory>& oFactory) const = 0;

        virtual tResult GetSampleInfo(ucom::ant::iobject_ptr<const ISampleInfo>& oSampleInfo) const = 0;

        virtual tResult GetSampleInfo(ucom::ant::iobject_ptr<ISampleInfo>& oSampleInfo) = 0;

        virtual tResult GetSampleLog(ucom::ant::iobject_ptr<ISampleLog>& oSampleLog) const = 0;

        ADTF3_DEPRECATED("Use adtf::streaming::flash::ISample::GetTimeNs() instead.")
        virtual tTimeStamp GetTime() const = 0;

        ADTF3_DEPRECATED("Use adtf::streaming::flash::ISample::SetTime(adtf::base::flash::tNanoSeconds tmTimeStamp) instead.")
        virtual tResult SetTime(tTimeStamp tmTimeStamp) = 0;
};
class ISample: public ucom::ant::IObject {…};

template<typename T>
tResult read_from_sample(const ISample& oSample, T& oValue)
{
    adtf::ucom::object_ptr_shared_locked<const ISampleBuffer> pSampleBuffer;
    RETURN_IF_FAILED(oSample.Lock(pSampleBuffer));
    return pSampleBuffer->Read(adtf::base::adtf_memory<void, sizeof(oValue)>(&oValue));
}
tResult read_from_sample(const ISample& oSample, T& oValue) {…}

template<typename T>
tResult write_to_sample(ISample& oSample, const T& oValue)
{
    static_assert(std::is_trivially_copyable<T>::value, "The data type needs to be trivially copyable.");
    adtf::ucom::object_ptr_locked<ISampleBuffer> pSampleBuffer;
    RETURN_IF_FAILED(oSample.WriteLock(pSampleBuffer, sizeof(oValue)));
    return pSampleBuffer->Write(adtf::base::adtf_memory<const void, sizeof(oValue)>(&oValue));
}
tResult write_to_sample(ISample& oSample, const T& oValue) {…}
 
} //namespace ant
 
namespace flash
{

class ISample: public ant::ISample
{
    protected:
        ~ISample() = default;
 
    public:
        ADTF_IID(ISample, "sample.flash.streaming.adtf.iid");
 
    public:
        using ant::ISample::SetTime;
        using ant::ISample::Set;

        virtual base::flash::tNanoSeconds GetTimeNs() const = 0;

        virtual tResult SetTime(base::flash::tNanoSeconds tmTimeStamp) = 0;

        virtual tResult Set(base::flash::tNanoSeconds tmTimeStamp,
                            const void*  pData,
                            size_t         szSize,
                            uint32_t       ui32Flags=0) = 0;
 
};
class ISample: public ant::ISample {…};
 
}
 
namespace hollow
{

class ISample: public flash::ISample
{
    protected:
        ~ISample() = default;
 
    public:
        ADTF_IID(ISample, "sample.hollow.streaming.adtf.iid");
 
    public:
        virtual uint32_t GetSubStreamId() const = 0;

        virtual void SetSubStreamId(uint32_t nSubStreamId) = 0;
};
class ISample: public flash::ISample {…};
 
}
 
namespace thor
{

class ISample: public hollow::ISample
{
    protected:
        ~ISample() = default;
 
    public:
        ADTF_IID(ISample, "sample.thor.streaming.adtf.iid");
 
    public:
        using hollow::ISample::Set;

        virtual tResult Set(const ant::ISample& oSample, size_t nOffset, size_t nSize) = 0;

        virtual tResult SetSampleBuffer(const ucom::ant::iobject_ptr<const ISampleBuffer>& pBuffer) = 0;
};
class ISample: public hollow::ISample {…};
 
}
 
// we keep ant::ISample as default, as this is what the streaming architecture and interfaces are able to transport.
using ant::ISample;
using ant::read_from_sample;
using ant::write_to_sample;
 
} //namespace streaming
} // namespace adtf