Example Demo Data Trigger

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Filter
  • Test

Description

Shows how to implement a filter which is triggered by input pins.

Prebuilt Binaries

• Demo Data Trigger

Source Code

./examples/demo_adtfplugins/demo_data_trigger/

Filter

demo_data_trigger_function.h

 
#pragma once
#include <adtffiltersdk/filter.h>
#include <adtfmediadescription/codec_sample_streamer.h>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif
 
class cSimpleDataCalculator final : public adtf::filter::cFilter
{
    public:
        ADTF_CLASS_ID_NAME(cSimpleDataCalculator,
                           "demo_data_trigger.filter" ADTF_EXAMPLES_CID,
                           "Demo Data Trigger");
 
    public:
        enum tOperator : uint32_t
        {
            ePLUS = 0,
            eMINUS = 1,
            eMULTI = 2,
            eDIVIDE = 3
        };
 
    public:
        cSimpleDataCalculator();
        ~cSimpleDataCalculator() override;
 
        tResult Init(tInitStage eStage) override;
 
        tResult ProcessInput(adtf::base::tNanoSeconds tmTrigger,
                             adtf::streaming::ISampleReader* pReader) override;
 
    private:
        // reader for our first input pin
        adtf::streaming::ISampleReader* m_pReader1 = nullptr;
        // reader for our second input pin
        adtf::streaming::ISampleReader* m_pReader2 = nullptr;
 
        // writer for our output pin
        adtf::streaming::ISampleWriter* m_pWriter = nullptr;
 
        // the selected calculation method
        std::function<float(float, float)> m_fnCalculator;
 
 
 
        // this will reflect any property changes.
        adtf::base::property_variable<tOperator> m_eOperator = ePLUS;
 
};

demo_data_trigger_function.cpp

 
#include "demo_data_trigger_function.h"
#include <functional>
 
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 Data Trigger Plugin", cSimpleDataCalculator);
 
cSimpleDataCalculator::cSimpleDataCalculator()
{
    // create our input pins with data-in triggers that call our overridden Process method.
    m_pReader1 = CreateInputPin("in1", stream_type_plain<float>(), true);
    SetDescription("in1", "First input value for calculation (in1 <operator> in2)");
    m_pReader2 = CreateInputPin("in2", stream_type_plain<float>(), true);
    SetDescription("in2", "Second input value for calculation (in1 <operator> in2)");
 
    m_pWriter = CreateOutputPin("out", stream_type_plain<float>());
    SetDescription("out", "Provides the calculated output (in1 <operator> in2)");
 
    // setup and register our property variable which will reflect any property change.
    // for compatibility with previous implementations we use the "data_generator_function" prefix.
    m_eOperator.SetValueList({{ePLUS, "PLUS"},
                              {eMINUS, "MINUS"},
                              {eMULTI, "MULTI"},
                              {eDIVIDE, "DIVIDE"}});
    m_eOperator.SetDescription("Chooses the arithmetic operation used to calculate the output values.");
    RegisterPropertyVariable("calculator_function/operator", m_eOperator);
 
    // sets a short description for the component
    SetDescription("Use this filter to calculate two input values while choosing the arithmetic operation with the property 'operator'.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_data_trigger.html");
}
 
cSimpleDataCalculator::~cSimpleDataCalculator() = default;
 
// in this method all property related and/or long running initialization can be done
tResult cSimpleDataCalculator::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(cFilter::Init(eStage));
 
    if (eStage == StageNormal)
    {
        switch (m_eOperator)
        {
            case ePLUS:
            {
                LOG_INFO("Current operation is Addition");
                m_fnCalculator = std::plus<float>();
                break;
            }
            case eMINUS:
            {
                LOG_INFO("Current operation is Subtraction");
                m_fnCalculator = std::minus<float>();
                break;
            }
            case eMULTI:
            {
                LOG_INFO("Current operation is Multiplication");
                m_fnCalculator = std::multiplies<float>();
                break;
            }
            case eDIVIDE:
            {
                LOG_INFO("Current operation is Division");
                m_fnCalculator = std::divides<float>();
                break;
            }
            default:
            {
                RETURN_ERROR_DESC(ERR_INVALID_ARG, "Invalid property value for 'operator'");
            }
        }
    }
 
    RETURN_NOERROR;
}

tResult cSimpleDataCalculator::ProcessInput(tNanoSeconds /*tmTrigger*/,
                                            ISampleReader* /*pReader*/)
{
    object_ptr<const ISample> pSample1;
    object_ptr<const ISample> pSample2;
 
    if (IS_OK(m_pReader1->GetLastSample(pSample1)) &&
        IS_OK(m_pReader2->GetLastSample(pSample2)))
    {
        auto tmSampleTimeStamp = std::max(get_sample_time(pSample1),
                                          get_sample_time(pSample2));
 
        output_sample_data<float> oOutput(tmSampleTimeStamp);
 
        oOutput = m_fnCalculator(sample_data<float>(pSample1),
                                 sample_data<float>(pSample2));
 
        m_pWriter->Write(oOutput.Release());
    }
 
    RETURN_NOERROR;
}

Test

test_demo_data_triggered_filter.cpp

#include "../demo_data_trigger_function.h"
 
#include <adtftesting/adtf_testing.h>
#include <adtfsystemsdk/testing/test_system.h>
#include <adtffiltersdk/adtf_filtersdk.h>
 
struct cMyTestSystem: adtf::system::testing::cTestSystem
{
    cMyTestSystem()
    {
        LoadPlugin("demo_data_triggered_filter.adtfplugin");
    }
};
 
adtf::ucom::object_ptr<adtf::streaming::IFilter> create_filter(cSimpleDataCalculator::tOperator eOperator)
{
    adtf::ucom::object_ptr<adtf::streaming::IFilter> pFilter;
    REQUIRE_OK(_runtime->CreateInstance("demo_data_trigger.filter" ADTF_EXAMPLES_CID, pFilter));
 
    auto pConfiguration = adtf::ucom::ucom_cast<adtf::base::IConfiguration*>(pFilter.Get());
    adtf::base::set_property_by_path<uint32_t>(*pConfiguration, "calculator_function/operator", eOperator);
 
    return pFilter;
}
 
void test_calculation(cSimpleDataCalculator::tOperator eOperator, float fExpectedResult)
{
    auto pFilter = create_filter(eOperator);
 
    adtf::filter::testing::cTestWriter oWriter1(pFilter, "in1", adtf::streaming::stream_type_plain<float>());
    adtf::filter::testing::cTestWriter oWriter2(pFilter, "in2", adtf::streaming::stream_type_plain<float>());
    adtf::filter::testing::cOutputRecorder oOutput(pFilter, "out");
 
    REQUIRE_OK(pFilter->SetState(adtf::streaming::IFilter::tFilterState::State_Running));
 
    oWriter1.Write<float>(4.0, true);
    oWriter2.Write<float>(2.0, true);
 
    auto oOutputSamples = oOutput.GetCurrentOutput().GetSamples();
 
    REQUIRE(oOutputSamples.size() == 1);
    REQUIRE(adtf::streaming::sample_data<float>(oOutputSamples.back()) == Approx(fExpectedResult));
}
 
TEST_CASE_METHOD(cMyTestSystem, "Test Addition")
{
    test_calculation(cSimpleDataCalculator::tOperator::ePLUS, 6.0);
}
 
TEST_CASE_METHOD(cMyTestSystem, "Test Substraction")
{
    test_calculation(cSimpleDataCalculator::tOperator::eMINUS, 2.0);
}
 
TEST_CASE_METHOD(cMyTestSystem, "Test Multiplication")
{
    test_calculation(cSimpleDataCalculator::tOperator::eMULTI, 8.0);
}
 
TEST_CASE_METHOD(cMyTestSystem, "Test Division")
{
    test_calculation(cSimpleDataCalculator::tOperator::eDIVIDE, 2.0);
}
 
TEST_CASE_METHOD(cMyTestSystem, "Test Invalid Operator")
{
    auto pFilter = create_filter(static_cast<cSimpleDataCalculator::tOperator>(cSimpleDataCalculator::tOperator::eDIVIDE + 1));
 
    REQUIRE(ERR_INVALID_ARG == pFilter->SetState(adtf::streaming::IFilter::tFilterState::State_Running));
}