Public Support

Hi Xinjie Huang,

There is no type information transmitted from Simulink to ADTF. Using the community message bus implementation only allows you to specify a DDL struct that is used to classify the data at the message bus source.

So define a DDL Struct that contains only a single float member and store it in a .description file that is then loaded by the Media Description Service. Then specify this struct in the 'struct_name' property of the message bus source and use the same definition for the Input Pin in your Filter.

Or for a quick hack just use 'stream_meta_type_anonymous' for the input pin, which will essentially accepts any type and disables any compatibility checks. This should of course be only used with caution and you are advised to only use it as a temporary solution until you have the DDL setup ready.

Regards,

Martin

Hi Martin,

Thank you for your quick answer. That quick hack worked. Now we have another question:

Suppose the processing filter is from a third party thus we don’t have the access to change it; and for sure there is no type information transmitted from Simulink to ADTF, which means we can’t change our input either. Then comes the question, is there any CONVERTOR in-between, that can convert our input according to the receiving filter? For the input data, we can generate a .description file from Simulink ADTF Tool.

Thank you and,
Best regards.

Xinjie Huang,

Hi Martin,

Thank you for your quick answer. That quick hack worked. Now we have another question:

Suppose the processing filter is from a third party thus we don’t have the access to change it; and for sure there is no type information transmitted from Simulink to ADTF, which means we can’t change our input either. Then comes the question, is there any CONVERTOR in-between, that can convert our input according to the receiving filter? For the input data, we can generate a .description file from Simulink ADTF Tool.

Thank you and,
Best regards.

Xinjie Huang

Hi Xinjie Huang,

no there is no such converter filter, for good reasons :-). As said before, use the 'struct_name' property of the message bus source to define the output stream type. This needs to be compatible to the one the connected filter expects.

Regards,

Martin

[Großmann-Neuhäusler telefonisch]
Es wird eine Fehlermeldung angezeigt
Ist es möglich, telefonisch mit Martin Heimlich in Kontakt zu treten?

@Franz Großmann-Neuhäusler
bitte diese Fehlermeldung hier im Ticket dokumentieren

Hi Xinjie & Franz,

yes, the stream types won't match. The Streaming source will provide a stream type of stream meta type "adtf/default" with a Media Description of "tmy_adtf_message_id_test" (or what you configured in the "struct_name" property). Judging from the plugindescription the Destination Filter expects a stream type of stream meta type "adtf/plain".

These two types are only compatible the other way around. i.e one filter can provide data of "adtf/plain" and another one can receive it with a stream type of "adtf/default" stream meta type set with the exact same media description:

<struct name="plain" alignment="1" version="1">
  <element name="value" arraysize="1" type="tInt32">
    <deserialized alignment="1"/>
    <serialized bytepos="0" byteorder="LE"/>
  </element>
</struct>

So if you cannot adjust the destination filter implementation, you unfortunately have to implement a conversion filter:

The simplest (but not very type safe method) would be:

class cPlainTypeOutputFilter: public cFilter
{
public:
    cPlainTypeOutputFilter()
    {
        CreateInputPin("input");
        m_pWriter = CreateOutputPin("output", stream_type_plain<tInt32>());
    }

    tResult ProcessInput(ISampleReader*, const iobject_ptr<const ISample>& pSample) override
    {
        m_pWriter->Write(pSample);
        RETURN_NOERROR;
    }
private:
    ISampleWriter* m_pWriter = nullptr;
};

Regards,

Martin

Keep in mind, that this only works if the data really is only one integer. If it is a more complex structure you have to access the individual elements in the conversion filter.

I quickly hacked this filter. Its not applicable for all use cases as it only supports outputing tInt32 values but should work for you.

class cElementExtractorFilter: public cFilter
{
public:
    cElementExtractorFilter()
    {
        RegisterPropertyVariable("element_name", m_strElementName);

        m_pReader = CreateInputPin<decoding_sample_reader<>>("input");
        m_pWriter = CreateOutputPin("output", stream_type_plain<tInt32>());
    }

    tResult ProcessInput(tNanoSeconds, ISampleReader*) override
    {
        cSampleDecoder oDecoder;
        tNanoSeconds tmSampleTime;

        while (m_pReader->GetNextDecoder(oDecoder, tmSampleTime))
        {
            output_sample_data<tInt32> oValue(tmSampleTime, oDecoder.GetElementValue(*m_strElementName).GetInt32());
            m_pWriter->Write(oValue.Release());
        }

        RETURN_NOERROR;
    }
private:
    property_variable<cString> m_strElementName;
    decoding_sample_reader<>* m_pReader = nullptr;
    ISampleWriter* m_pWriter = nullptr;
};

Grüße,

Martin

I have now implemented a generic extractor filter, which should handle every case:

class cElementExtractorFilter: public cFilter
{
public:
    ADTF_CLASS_ID_NAME(cElementExtractorFilter,
                       "element_extractor_trigger.filter.adtf.cid",
                       "Element Extractor");
public:
    cElementExtractorFilter()
    {
        RegisterPropertyVariable("element_name", m_strElementName);

        m_pReader = CreateInputPin<decoding_sample_reader<>>("input");
        m_pWriter = CreateOutputPin("output");
    }

    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, m_nElementIndex),
                              "Unable to find element '%s' in source stream type", m_strElementName->GetPtr());

        object_ptr<IStreamType> pNewType;
        const auto& oElement = m_pReader->GetStaticElement(m_nElementIndex);
        switch (oElement.eType)
        {
        case VT_Int8: pNewType = make_object_ptr<stream_type_plain<tInt8>>(); m_nTypeSize = 1; break;
        case VT_UInt8: pNewType = make_object_ptr<stream_type_plain<tUInt8>>(); m_nTypeSize = 1; break;
        case VT_Int16: pNewType = make_object_ptr<stream_type_plain<tInt16>>(); m_nTypeSize = 2; break;
        case VT_UInt16: pNewType = make_object_ptr<stream_type_plain<tUInt16>>(); m_nTypeSize = 2; break;
        case VT_Int32: pNewType = make_object_ptr<stream_type_plain<tInt32>>(); m_nTypeSize = 4; break;
        case VT_UInt32: pNewType = make_object_ptr<stream_type_plain<tUInt32>>(); m_nTypeSize = 4; break;
        case VT_Int64: pNewType = make_object_ptr<stream_type_plain<tInt64>>(); m_nTypeSize = 8; break;
        case VT_UInt64: pNewType = make_object_ptr<stream_type_plain<tUInt64>>(); m_nTypeSize = 8; break;
        case VT_Float32: pNewType = make_object_ptr<stream_type_plain<tFloat32>>(); m_nTypeSize = 4; break;
        case VT_Float64: pNewType = make_object_ptr<stream_type_plain<tFloat64>>(); m_nTypeSize = 8; break;
        default:
            RETURN_ERROR_DESC(ERR_NOT_SUPPORTED, "Unsupported element typo '%d'", oElement.eType);
        }

        m_pWriter->ChangeType(pNewType);

        RETURN_NOERROR;
    }

    tResult ProcessInput(tNanoSeconds, ISampleReader*) override
    {
        cSampleDecoder oDecoder;
        tNanoSeconds tmSampleTime;

        while (m_pReader->GetNextDecoder(oDecoder, tmSampleTime))
        {
            object_ptr<ISample> pSample;
            RETURN_IF_FAILED(alloc_sample(pSample, tmSampleTime));

            {
                object_ptr_locked<ISampleBuffer> pBuffer;
                RETURN_IF_FAILED(pSample->WriteLock(pBuffer, m_nTypeSize));
                oDecoder.GetElementValue(m_nElementIndex, pBuffer->GetPtr());
            }

            m_pWriter->Write(pSample);
        }

        RETURN_NOERROR;
    }
private:
    property_variable<cString> m_strElementName;
    decoding_sample_reader<>* m_pReader = nullptr;
    ISampleWriter* m_pWriter = nullptr;
    tSize m_nElementIndex = 0;
    tSize m_nTypeSize = 0;
};

Hi Digitalwerk Support,

I thought that this ticket has been set to resolved that it doesn’t need feedback from us, sorry for that.
The filter now works perfect! This ticket can be closed.
We would like to thank you again for your support!

Best regards,
Xinjie