Example Demo Requestable Substream Filter

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Filter

Description

Shows how to handle incoming substream requests.

Prebuilt Binaries

• Demo Requestable Substream Generator

Source Code

./examples/demo_adtfplugins/demo_requestable_substream_filter/

Filter

requestable_substream_generator_filter.cpp

 
#include "requestable_substream_generator_filter.h"
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::filter;
 
// this creates the plugin entry methods and class factories
ADTF_PLUGIN("Demo Requestable Substream Generator Plugin", cDemoRequestableSubStreamGenerator);
 
cDemoRequestableSubStreamGenerator::cDemoRequestableSubStreamGenerator()
{
    // sets a short description for the component
    SetDescription("Use this filter to generate data of (requested) multiple substreams whenever a timer triggers");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_requestable_substream_generator.html");
 
    CreateRunner("generate_samples");
    SetDescription("generate_samples",
                   "Runner to periodically trigger the function which generates samples for the substreams.");
 
    // we use the helper class cSubStreamTypes to generate a stream type with the
    // adtf::streaming::stream_meta_type_substreams meta type that contains
    // multiple stream type definitions.
    cSubStreamTypes oSubStreams;
    oSubStreams.SetSubStream("stream1", 0, stream_type_plain<uint32_t>());
    oSubStreams.SetSubStream("stream2", 1, stream_type_plain<uint32_t>());
    oSubStreams.SetSubStream("stream3", 2, stream_type_plain<uint32_t>());
 
    // now create our output pin with enabled streaming requests.
    m_pWriter = CreateRequestableOutputPin("output", oSubStreams);
    SetDescription("output", "Provides the generated substreams");
}
 
cDemoRequestableSubStreamGenerator::~cDemoRequestableSubStreamGenerator() = default;
 
// to handle new requests we override this method.
tResult cDemoRequestableSubStreamGenerator::EnableSubStream(ISampleWriter* /*pWriter*/,
                                                            uint32_t nSubStreamId,
                                                            const IProperties* /*pRequestProperties*/)
{
    if (nSubStreamId > 2)
    {
        RETURN_ERROR_DESC(ERR_INVALID_ARG, "No substream with id %" PRIu32 " available", nSubStreamId);
    }
 
    m_oEnabledSubStreams.insert(nSubStreamId);
    LOG_INFO("Enabled substream %" PRIu32, nSubStreamId);
    RETURN_NOERROR;
}
 
// to handle closed requests we override this method.
void cDemoRequestableSubStreamGenerator::DisableSubStream(ISampleWriter* /*pWriter*/, uint32_t nSubStreamId)
{
    m_oEnabledSubStreams.erase(nSubStreamId);
    LOG_INFO("Disabled substream %u", nSubStreamId);
}
 
tResult cDemoRequestableSubStreamGenerator::Process(tNanoSeconds tmTrigger, IRunner* /*pRunner*/)
{
    ++m_nTriggerCounter;
 
    for (const auto& nSubStreamId : m_oEnabledSubStreams)
    {
        // when generating samples we set the substream id.
        // in this case we just pass it to the output_sample_data constructor.
        // Otherwise take a look at adtf::streaming::set_sample_substream_id() and
        // adtf::streaming::hollow::ISample::SetSubStreamId().
        output_sample_data<uint32_t> oNewData(tmTrigger, m_nTriggerCounter + (nSubStreamId * 1000), nSubStreamId);
 
        m_pWriter->Write(oNewData.Release());
    }
 
    RETURN_NOERROR;
}