Source Code for Demo Thread Trigger Plugin

Location

./src/examples/src/adtf/filters/standard_filters/thread_triggered_filter/

Build Environment

To see how to set up the build environment have a look at ADTF CMake Environment

this implementation shows:

• how to create a thread triggered Filter.
• how to work with Stream Meta Type, adtf::streaming::ant::stream_type_plain.
• how to handle a adtf::base::ant::cPropertyVariable.
• how to receive data from adtf::streaming::flash::ISampleReader.
• how to access sample data with adtf::streaming::flash::sample_data.

Header

 
#pragma once
#include <adtffiltersdk/filter.h>
 
#include <condition_variable>
#include <mutex>
 
using namespace adtf::util;
using namespace ddl;
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::mediadescription;
using namespace adtf::filter;
 
class cAsynchronousDataPrinter : public cFilter
{
    public:
        ADTF_CLASS_ID_NAME(cAsynchronousDataPrinter,
                           "demo_thread_trigger.filter.adtf.cid",
                           "Demo Thread Trigger");
    public:
        cAsynchronousDataPrinter();
 
        tResult ProcessInput(tNanoSeconds tmTrigger,
                             ISampleReader* pReader) override;
 
    private:
        tResult PrintData();
 
    private:
        // reader for our input pin
        ISampleReader* m_pReader = nullptr;
 
        // this is used to signal the thread that executes our trigger function
        std::mutex m_oSamplesAvailableMutex;
        std::condition_variable m_oSamplesAvailable;
 
        size_t m_nSampleCounter = 0;
};

Implementation

 
#include "demo_thread_trigger_function.h"
 
// this creates the plugin entry methods and class factories
ADTF_PLUGIN("Demo Thread Trigger Plugin", cAsynchronousDataPrinter);
 
cAsynchronousDataPrinter::cAsynchronousDataPrinter()
{
    // create our input pin with a data-in trigger that calls our overridden Process method.
    m_pReader = CreateInputPin("in", stream_type_plain<float>(), true);
    SetDescription("in", "Input value for printing");
 
    // create a trigger function that can be connected to an active runner.
    CreateRunner("print_data",
                          std::bind(&cAsynchronousDataPrinter::PrintData, this),
                          cThreadTriggerHint());
    SetDescription("print_data", "Runner to cyclically trigger the function which prints the data");
 
    // sets a short description for the component
    SetDescription("Use this filter to print asynchronously the received values with a defined Thread Runner.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/adtf_html/page_demo_thread_triggered_filter.html");
}
 
// this is called when a data trigger is received at the input pin.
tResult cAsynchronousDataPrinter::ProcessInput(tNanoSeconds /*tmTrigger*/,
                                               ISampleReader* /*pReader*/)
{
    // all we do is notify the trigger function that there might be some samples available.
    m_oSamplesAvailable.notify_all();
    RETURN_NOERROR;
}
 
// this method is called repeatedly by an active thread runner
tResult cAsynchronousDataPrinter::PrintData()
{
    object_ptr<const ISample> pSample;
 
    // wait until a sample should be available to read.
    // we use a timeout to ensure that this method finishes eventually.
    std::unique_lock<std::mutex> oGuard(m_oSamplesAvailableMutex);
    if (m_oSamplesAvailable.wait_for(oGuard, std::chrono::milliseconds(10), [&]
                                     {
                                         return IS_OK(m_pReader->GetNextSample(pSample));
                                     }))
    {
        float fValue = sample_data<float>(pSample);
        LOG_INFO("value number %ld: %f", ++m_nSampleCounter, fValue);
    }
 
    RETURN_NOERROR;
}