Public Support

#include <adtffiltersdk/adtf_filtersdk.h>

#include <adtfmediadescription/adtf_mediadescription.h>

using namespace adtf::util;

using namespace adtf::ucom;

using namespace adtf::base;

using namespace adtf::streaming;

using namespace adtf::filter;

using namespace adtf::mediadescription;

class cElementExtractorFilter: public cFilter

{

public:

    ADTF_CLASS_ID_NAME(cElementExtractorFilter,

                       "element_extractor.filter.adtf.cid",

                       "Element Extractor");

public:

    cElementExtractorFilter()

    {

        m_strElementName.SetDescription("The name of the structure element that should be extracted and forwarded.");

        RegisterPropertyVariable("element_name", m_strElementName);

        m_eTargetType.SetValueList(

        {

            {VT_Int8, "Int8"},

            {VT_UInt8, "UInt8"},

            {VT_Int16, "Int16"},

            {VT_UInt16, "UInt16"},

            {VT_Int32, "Int32"},

            {VT_UInt32, "UInt32"},

            {VT_Int64, "Int64"},

            {VT_UInt64, "UInt64"},

            {VT_Float32, "Float32"},

            {VT_Float64, "Float64"}

        });

        RegisterPropertyVariable("output_type", m_eTargetType);

        m_pReader = CreateInputPin<decoding_sample_reader<>>("input");

        SetDescription("input", "The data of which the given element should be extracted.");

        m_pWriter = CreateOutputPin("output");

        SetDescription("output", "The element data will be forwarded here");

        // sets a short description for the component

        SetDescription("Use this filter to extract an element from complex input data (i.e. structures).");

        // set help link to jump to documentation from ADTF Configuration Editor

        SetHelpLink("$(ADTF_DIR)/doc/adtf_html/page_demo_element_extractor_filter.html");

    }

    tResult AcceptType(ISampleReader* pReader,

                       const adtf::ucom::iobject_ptr<const IStreamType>& pType) override

    {

        RETURN_IF_FAILED(cFilter::AcceptType(pReader, pType));

        RETURN_IF_FAILED_DESC(ddl::access_element::find_index(*m_pReader, m_strElementName->c_str(), m_nElementIndex),

                              "Unable to find element '%s' in source stream type", m_strElementName->c_str());

        object_ptr<IStreamType> pNewType;

        switch (m_eTargetType)

        {

        case VT_Int8: pNewType = make_object_ptr<stream_type_plain<tInt8>>(); break;

        case VT_UInt8: pNewType = make_object_ptr<stream_type_plain<tUInt8>>(); break;

        case VT_Int16: pNewType = make_object_ptr<stream_type_plain<tInt16>>(); break;

        case VT_UInt16: pNewType = make_object_ptr<stream_type_plain<tUInt16>>(); break;

        case VT_Int32: pNewType = make_object_ptr<stream_type_plain<tInt32>>(); break;

        case VT_UInt32: pNewType = make_object_ptr<stream_type_plain<tUInt32>>(); break;

        case VT_Int64: pNewType = make_object_ptr<stream_type_plain<tInt64>>(); break;

        case VT_UInt64: pNewType = make_object_ptr<stream_type_plain<tUInt64>>(); break;

        case VT_Float32: pNewType = make_object_ptr<stream_type_plain<tFloat32>>(); break;

        case VT_Float64: pNewType = make_object_ptr<stream_type_plain<tFloat64>>(); break;

        default:

            RETURN_ERROR_DESC(ERR_NOT_SUPPORTED, "Unsupported element type '%d'", *m_eTargetType);

        }

        m_pWriter->ChangeType(pNewType);

        RETURN_NOERROR;

    }

    /// this function will be executed each time a trigger occured on one of the input pins.

    /// it is possible that more than one sample is available at the reader.

    tResult ProcessInput(tNanoSeconds, ISampleReader*) override

    {

        cSampleDecoder oDecoder;

        tNanoSeconds tmSampleTime;

        while (m_pReader->GetNextDecoder(oDecoder, tmSampleTime))

        {

            const auto oValue = oDecoder.GetElementValue(m_nElementIndex);

            object_ptr<ISample> pSample;

            switch (m_eTargetType)

            {

            case VT_Int8: pSample = output_sample_data<tInt8>(tmSampleTime, oValue.GetInt8()).Release(); break;

            case VT_UInt8: pSample = output_sample_data<tUInt8>(tmSampleTime, oValue.GetUInt8()).Release(); break;

            case VT_Int16: pSample = output_sample_data<tInt16>(tmSampleTime, oValue.GetInt16()).Release(); break;

            case VT_UInt16: pSample = output_sample_data<tUInt16>(tmSampleTime, oValue.GetUInt16()).Release(); break;

            case VT_Int32: pSample = output_sample_data<tInt32>(tmSampleTime, oValue.GetInt32()).Release(); break;

            case VT_UInt32: pSample = output_sample_data<tUInt32>(tmSampleTime, oValue.GetUInt32()).Release(); break;

            case VT_Int64: pSample = output_sample_data<tInt64>(tmSampleTime, oValue.GetInt64()).Release(); break;

            case VT_UInt64: pSample = output_sample_data<tUInt64>(tmSampleTime, oValue.GetUInt64()).Release(); break;

            case VT_Float32: pSample = output_sample_data<tFloat32>(tmSampleTime, oValue.GetFloat32()).Release(); break;

            case VT_Float64: pSample = output_sample_data<tFloat64>(tmSampleTime, oValue.GetFloat64()).Release(); break;

            default:

                RETURN_ERROR(ERR_UNEXPECTED);

            }

            m_pWriter->Write(pSample);

        }

        RETURN_NOERROR;

    }

private:

    property_variable<std::string> m_strElementName;

    decoding_sample_reader<>* m_pReader = nullptr;

    ISampleWriter* m_pWriter = nullptr;

    tSize m_nElementIndex = 0;

    property_variable<tVariantType> m_eTargetType = VT_Float64;

};

// this creates the plugin entry methods and class factories

ADTF_PLUGIN("Demo Element Extractor Filter Plugin", cElementExtractorFilter);