Example Demo Thread Trigger

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Filter

Description

Shows how to implement a filter which is triggered by a Thread Runner.

Prebuilt Binaries

• Demo Thread Trigger

Source Code

./examples/demo_adtfplugins/demo_thread_trigger/

Filter

demo_thread_trigger_function.h

 
#pragma once
#include <adtffiltersdk/filter.h>
 
#include <condition_variable>
#include <mutex>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif
 
class cAsynchronousDataPrinter final : public adtf::filter::cFilter
{
    public:
        ADTF_CLASS_ID_NAME(cAsynchronousDataPrinter,
                           "demo_thread_trigger.filter" ADTF_EXAMPLES_CID,
                           "Demo Thread Trigger");
    public:
        cAsynchronousDataPrinter();
        ~cAsynchronousDataPrinter() override;
 
        tResult ProcessInput(adtf::base::tNanoSeconds tmTrigger,
                             adtf::streaming::ISampleReader* pReader) override;
 
    private:
        tResult PrintData();
 
    private:
        // reader for our input pin
        adtf::streaming::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;
};

demo_thread_trigger_function.cpp

 
#include "demo_thread_trigger_function.h"
 
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;
 
// 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/html/page_demo_thread_trigger.html");
}
 
cAsynchronousDataPrinter::~cAsynchronousDataPrinter() = default;
 
// 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 %" PRIuPTR ": %f", ++m_nSampleCounter, fValue);
    }
 
    RETURN_NOERROR;
}