Example Demo Sample Data Reference

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Streaming Source

Description

Shows how to process samples with zero-copy.

Prebuilt Binaries

• Demo Sample Data Reference Generator

Source Code

./examples/demo_adtfplugins/demo_sample_data_reference/

Streaming Source

demo_sample_data_reference_source.h

 
#pragma once
 
#include <adtffiltersdk/adtf_filtersdk.h>
#include <adtfsystemsdk/adtf_systemsdk.h>
#include <adtffiltersdk/runner_fallback.h>
 
#include <memory>
#include <vector>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif

class cReferenceBuffer: public adtf::ucom::object<adtf::streaming::ISampleBuffer>
{
public:
    cReferenceBuffer(std::shared_ptr<const std::vector<uint8_t>> pSharedBuffer):
        m_pSharedBuffer(std::move(pSharedBuffer))
    {
    }
 
    ~cReferenceBuffer()
    {
        // the reference to the shared buffer will be released when this object is destroyed
    }
 
    tResult Lock() const override
    {
        // this is a read only buffer
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
    tResult Unlock() const override
    {
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
    tResult LockShared() const override
    {
        // this buffer will not be changed during its lifetime, so no locking required
        RETURN_NOERROR;
    }
 
    tResult UnlockShared() const override
    {
        RETURN_NOERROR;
    }
 
    tResult Write(const adtf::base::IRawMemory& /* oBufferWrite */) override
    {
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
    tResult Read(adtf::base::IRawMemory&& oBufferRead) const override
    {
        RETURN_IF_FAILED(oBufferRead.Set(m_pSharedBuffer->data(), m_pSharedBuffer->size()));
        RETURN_NOERROR;
    }
 
    void* GetPtr() override
    {
        return nullptr;
    }
 
    const void* GetPtr() const override
    {
        return m_pSharedBuffer->data();
    }
 
    size_t GetSize() const override
    {
        return m_pSharedBuffer->size();
    }
 
    size_t GetCapacity() const override
    {
        return m_pSharedBuffer->size();
    }
 
    tResult Reserve(size_t /* szSize */) override
    {
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
    tResult Resize(size_t /* szSize */) override
    {
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
private:
    const std::shared_ptr<const std::vector<uint8_t>> m_pSharedBuffer;
};
 
 
//*************************************************************************************************
class cDemoSampleDataReferenceSource final : public adtf::filter::cSampleStreamingSource
{
    public:
        ADTF_CLASS_ID_NAME(cDemoSampleDataReferenceSource,
                           "demo_sample_data_reference_generator.streaming_source" ADTF_EXAMPLES_CID,
                           "Demo Sample Data Reference Generator");
 
        ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::services::IReferenceClock),
                                REQUIRE_INTERFACE(adtf::services::IKernel));
 
    private:
        adtf::base::property_variable<uint32_t> m_nWidth = 640;
        adtf::base::property_variable<uint32_t> m_nHeight = 480;
        adtf::base::property_variable<int64_t> m_nFrameDelay = 1000000;
        adtf::ucom::object_ptr<adtf::services::IReferenceClock> m_pClock;
 
        adtf::streaming::ISampleWriter* m_pOutputWriter = nullptr;
        adtf::filter::cRunnerFallback m_oTimer;
 
    public:
        cDemoSampleDataReferenceSource();
        ~cDemoSampleDataReferenceSource() override;
 
        tResult Init() override;
        tResult StartStreaming() override;
        tResult StopStreaming() override;
 
    private:
        std::shared_ptr<const std::vector<uint8_t>> GetRandomBuffer();
        adtf::ucom::object_ptr<adtf::streaming::IStreamType> GetStreamTypeFromProperties();
        void TimerFunc();
};

demo_sample_data_reference_source.cpp

#include "demo_sample_data_reference_source.h"
 
using namespace adtf::base;
using namespace adtf::ucom;
using namespace adtf::streaming;
using namespace adtf::filter;
using namespace adtf::system;
 
// Avoid Warning C4244 in std::generate(m_oBuffer.begin(), m_oBuffer.end(), std::rand)
namespace {
    unsigned char generator()
    {
        return static_cast<unsigned char>(std::rand());
    }
}
 
ADTF_PLUGIN("Demo Sample Data Reference Plugin",
            cDemoSampleDataReferenceSource);
 
cDemoSampleDataReferenceSource::cDemoSampleDataReferenceSource()
{
    m_nWidth.SetDescription("Specified width for Sample dimension.");
    RegisterPropertyVariable("width", m_nWidth);
 
    m_nHeight.SetDescription("Specified height for Sample dimension.");
    RegisterPropertyVariable("height", m_nHeight);
 
    m_nFrameDelay.SetDescription("Update interval in microseconds for Sample creation. This is only used when no Timer Runner is connected to the 'generate_frames' runner.");
    RegisterPropertyVariable("frame_delay", m_nFrameDelay);
 
    m_pOutputWriter = CreateOutputPin("output", GetStreamTypeFromProperties());
    SetDescription("output", "Provides the generated referenced samples");
 
    // For session compatibility reasons we use this fallback helper for the case where no active runner is connected to the runner.
    // In your own implementations use a simple CreateRunner(...) instead.
    m_oTimer = adtf::filter::cRunnerFallback(this, "generate_frames", cTimerTriggerHint(*m_nFrameDelay),[this]{ TimerFunc(); });
    SetDescription("generate_frames",
                   "Connect a Timer Runner that will trigger the frame generation. In this case the property `frame_delay` has no effect."
                   "If this is not connected, the source will create a timer on its own.");
 
    // sets a short description for the component
    SetDescription("Use this streaming source to to generate samples that reference external data.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_sample_data_reference_generator.html");
}
 
cDemoSampleDataReferenceSource::~cDemoSampleDataReferenceSource() = default;
 
tResult cDemoSampleDataReferenceSource::Init()
{
    RETURN_IF_FAILED(cSampleStreamingSource::Init());
    m_pOutputWriter->ChangeType(GetStreamTypeFromProperties());
    RETURN_NOERROR;
}
 
object_ptr<IStreamType> cDemoSampleDataReferenceSource::GetStreamTypeFromProperties()
{
    tStreamImageFormat sFormat;
    sFormat.m_strFormatName = ADTF_IMAGE_FORMAT(GREYSCALE_8);
    sFormat.m_ui32Width = m_nWidth;
    sFormat.m_ui32Height = m_nHeight;
    sFormat.m_szMaxByteSize = m_nWidth * m_nHeight;
    sFormat.m_ui8DataEndianess = PLATFORM_BYTEORDER;
    object_ptr<IStreamType> pType = make_object_ptr<cStreamType>(stream_meta_type_image());
    set_stream_type_image_format(*pType, sFormat);
    return pType;
}
 
 
tResult cDemoSampleDataReferenceSource::StartStreaming()
{
    RETURN_IF_FAILED(cSampleStreamingSource::StartStreaming());
    RETURN_IF_FAILED(_runtime->GetObject(m_pClock));
 
    RETURN_IF_FAILED(m_oTimer.Activate(m_nFrameDelay));
 
    RETURN_NOERROR;
}
 
tResult cDemoSampleDataReferenceSource::StopStreaming()
{
    m_oTimer.Deactivate();
    return cSampleStreamingSource::StopStreaming();
}
 
std::shared_ptr<const std::vector<uint8_t>> cDemoSampleDataReferenceSource::GetRandomBuffer()
{
    const auto pBuffer = std::make_shared<std::vector<uint8_t>>(m_nWidth * m_nHeight);
    std::generate(pBuffer->begin(), pBuffer->end(), generator);
    return pBuffer;
}
 
void cDemoSampleDataReferenceSource::TimerFunc()
{
    auto tmNow = m_pClock->GetStreamTimeNs();
 
    try
    {
        object_ptr<adtf::streaming::thor::ISample> pSample;
        {
            THROW_IF_FAILED(alloc_sample(pSample, tmNow));
            const auto pNewBuffer = adtf::ucom::make_object_ptr<cReferenceBuffer>(GetRandomBuffer());
            THROW_IF_FAILED(pSample->SetSampleBuffer(adtf::ucom::ucom_object_ptr_cast<const adtf::streaming::ISampleBuffer>(pNewBuffer)));
        }
 
        m_pOutputWriter->Write(ucom_object_ptr_cast<ISample>(pSample));
        m_pOutputWriter->ManualTrigger(tmNow);
    }
    catch(...)
    {
        m_pOutputWriter->SetStreamError(CURRENT_EXCEPTION());
    }
}