Overview of writing and reading samples

Table of Contents

• ADTF standard data
  • Arithmetic data types
    • Arithmetic data
    • Array of arithmetic data
  • Structured data types
    • Structured data
    • Array of structured data
• Video types
  • Video image data
• Dynamic data in size
  • String data
  • Dynamic arrays within structured data
• Custom data

ADTF standard data

By using ADTF standard data and the supported types following components can be connected: Qt5 Media Description Display Qt5 JavaScript Filter Qt5 QML Filter Qt5 Substream Display (BETA) DDL Mapping Filter DDL Mapping Filter Substream Dissector

Additionally, if the samples content is described via DDL, it is possible to use DDL based DAT File Exporter and Importer.

Arithmetic data types

Arithmetic data

Supported data types

uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, int64_t, float, double

Recommended Stream Type to use

Use the stream_type_plain as instance of Stream Meta Type "adtf/plaintype" for single small arithmetic data.

Output

Describe the data with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T>
using namespace adtf::filter;    // to use pin_writer<T>
 
// create the adtf::filter::pin_writer<uint8_t>* m_pWriter_1 instance
// by using stream_type_plain<T> generator template
m_pWriter_1 = CreateOutputPin<pin_writer<uint8_t>>("out_plain_1", stream_type_plain<uint8_t>());
 
// create a adtf::streaming::ISampleWriter* m_pWriter_2 instance
// by using stream_type_plain<T> generator template
m_pWriter_2 = CreateOutputPin("out_plain_2", stream_type_plain<uint8_t>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_plains", cTimerTriggerHint(100));
 

Write Samples

Write the data with the help of operator<< or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner) override
{
    using namespace adtf::streaming;
    
    if (pRunner == m_pRunner)
    {
        uint8_t nValue = 42;
        // for pin_writer<T>
        // write the value into a new sample with time of trigger
        RETURN_IF_FAILED(m_pWriter_1->Write(tmTrigger, nValue));
 
        using namespace adtf::streaming; // to use output_sample_data<T>
        // for ISampleWriter
        // write the sample by creating an output_sample_data with time of trigger
        *m_pWriter_2 << output_sample_data(tmTrigger, nValue);
    }
    RETURN_NOERROR;
}

Input

Describe the expected input with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T> 
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_plain<T> generator template
m_pReader_1 = CreateInputPin("in_plain_1", stream_type_plain<uint8_t>());
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// by using stream_type_plain<T> generator template
m_pReader_2 = CreateInputPin("in_plain_2", stream_type_plain<uint8_t>());
 

Read Samples

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content
        sample_data<uint8_t> oSampleData(pSample);
 
        // i.e. access the value with operator*
        uint8_t nValue = *oSampleData;
        // i.e. access the value with GetData()
        nValue = oSampleData.GetData();
 
        // log the value
        LOG_INFO("Value is %d", int(nValue));
    }
    // ... do the same for m_pReader_2
 
    RETURN_NOERROR;
}

Array of arithmetic data

Supported data types

std::array<T, N>, where T is: uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, int64_t, float, double
 
T[N], where T is: uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, int64_t, float, double

Recommended Stream Type to use

Use stream_type_plain as instance of Stream Meta Type "adtf/plaintype" for arrays of arithmetic data.

Output for std::array<T, N>

Describe the data with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T>
using namespace adtf::filter; // to use pin_writer<T>
 
// create the pin_writer<std::array<uint8_t, 4>>* m_pWriter_1 instance
// by using stream_type_plain<T> generator template
m_pWriter_1 = CreateOutputPin<pin_writer<std::array<uint8_t, 4>>>("out_plain_std_array_1",
                                                                  stream_type_plain<std::array<uint8_t, 4>>());
 
// create the adtf::streaming::ISampleWriter* m_pWriter_2 instance
// by using using stream_type_plain<T> generator template
m_pWriter_2 = CreateOutputPin("out_plain_std_array_2", stream_type_plain<std::array<uint8_t, 4>>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_std_arrays", cTimerTriggerHint(100));
 

Write Samples for std::array<T, N>

Write the data with the help of the pin_writer<T>::Write method or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTigger, adtf::streaming::IRunner* pRunner) override
{
    if (pRunner == m_pRunner)
    {
        std::array<uint8_t, 4> aStdArrayValues = {1, 2, 3, 4};
        // for pin_writer<T>
        // write the value into a new sample with time of trigger
        RETURN_IF_FAILED(m_pWriter_1->Write(tmTigger, aStdArrayValues));
 
        using namespace adtf::streaming; // to use output_sample_data<T>
        // for ISampleWriter
        // writes the sample by creating output_sample_data with time of trigger
        *m_pWriter_2 << output_sample_data(tmTigger, aStdArrayValues);
    }
    RETURN_NOERROR;
}

Input for std::array<T, N>

Describe the expected input with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_plain<T> generator template
m_pReader_1 = CreateInputPin("in_plain_std_array_1", stream_type_plain<std::array<uint8_t, 4>>());
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// by using stream_type_plain<T> generator template
m_pReader_2 = CreateInputPin("in_plain_std_array_2", stream_type_plain<std::array<uint8_t, 4>>());
 

Read Samples for std::array<T, N>

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
 
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content of the std::array
        sample_data<std::array<uint8_t, 4>> oSampleDataStdArray(pSample);
 
        // i.e. access the value with operator*
        std::array<uint8_t, 4> aStdArrayValues = *oSampleDataStdArray;
        // i.e. access the value with GetData()
        aStdArrayValues = oSampleDataStdArray.GetData();
    }
    // ... do the same for m_pReader_2
 
    RETURN_NOERROR;
}

Output for T[N]

Describe the data with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T>
using namespace adtf::filter; // to use pin_writer<T>
 
// create the adtf::filter::pin_writer<uint8_t[4]>* m_pWriter_1 instance
// by using stream_type_plain<T> template
m_pWriter_1 = CreateOutputPin<pin_writer<uint8_t[4]>>("out_plain_array_1", stream_type_plain<uint8_t[4]>());
 
// create the adtf::streaming::ISampleWriter* m_pWriter_2 instance
// by using stream_type_plain<T> template
m_pWriter_2 = CreateOutputPin("out_plain_array_2", stream_type_plain<uint8_t[4]>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_arrays", cTimerTriggerHint(100));
 

Write Samples for for T[N]

Write the data with the help of pin_writer<T>::Write method or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner)
{
    if (pRunner == m_pRunner)
    {
        uint8_t aArrayValues[4] = {1, 2, 3, 4};
        // for pin_writer<T[N]>
        // write the value into a new sample with time of trigger
        RETURN_IF_FAILED(m_pWriter_1->Write(tmTrigger, aArrayValues));
 
        using namespace adtf::streaming; // to use output_sample_data<T>
        // for ISampleWriter
        // writes the sample by creating output_sample_data with time of trigger
        *m_pWriter_2 << output_sample_data(tmTrigger, aArrayValues);
    }
    RETURN_NOERROR;
}

Input for T[N]

Describe the expected input with stream_type_plain

using namespace adtf::streaming; // to use stream_type_plain<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// i.e. using stream_type_plain<T> generator template
m_pReader_1 = CreateInputPin("in_plain_array_1", stream_type_plain<uint8_t[4]>());
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// i.e. using stream_type_plain<T> generator template
m_pReader_2 = CreateInputPin("in_plain_array_2", stream_type_plain<uint8_t[4]>());
 

Read Samples for T[N]

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
 
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content of the std::array
        sample_data<uint8_t[4]> oSampleDataArray(pSample);
 
        // i.e. access the value with operator*
        for (auto nIndex = 0; nIndex < 4; ++nIndex)
        {
            LOG_INFO("Value[%d]=%d", int(nIndex), int((*oSampleDataArray)[nIndex]));
        }
 
        // i.e. access the value with GetData()
        for (auto nIndex = 0; nIndex < 4; ++nIndex)
        {
            LOG_INFO("Value[%d]=%d", int(nIndex), int(oSampleDataArray.GetData()[nIndex]));
        }
    }
    // ... do the same for m_pReader_2
 
    RETURN_NOERROR;
}

Structured data types

Structured data

Supported data types

The conditions to use structured data as content of a sample is:

• The type has to fulfill the condition of std::is_trivially_copyable<T>::value to be true
• No pointer types are allowed as member
• All members has to fullfill the condition of std::is_trivially_copyable<T>::value to be true

  // example structure that is trivially copyable
  struct tMyType
  {
      int32_t m_nValue1;
      double  m_fValue2;
      bool    m_bArray[2];
  };
   

• It is also possible to define a DDL description file and use the generated type by MD Generator Tool.

   
  // this file is generated with MD Generator Tool
  #include <my_type.h>
   

Recommended Stream Type to use

Use the stream_type_default as instance of Stream Meta Type "adtf/default" for structured data.
Usually, you are allowed to use every kind of your own Custom Stream Meta Types to describe the structured data you want to write. The big advantage of using the stream_type_default is to describe the content by the help of the Data Definition Language (DDL). See also DDL and ADTF 3, how to create a description for your structured data.

Output

Describe the data with stream_type_default

using namespace adtf::mediadescription; // to use stream_type_default<T>
using namespace adtf::filter;           // to use pin_writer<T>
 
// i.e. we create a structure ddl description with the help of "type reflection"
auto oDescriptionForMyType = structure<tMyType>("tMyType")
                                  .Add("m_nValue1", &tMyType::m_nValue1)
                                  .Add("m_fValue2", &tMyType::m_fValue2)
                                  .Add("m_bArray", &tMyType::m_bArray);
 
// create the adtf::filter::pin_writer<tMyType>* m_pWriter_1 instance
// i.e. by using stream_type_default<> generator template
m_pWriter_1 = CreateOutputPin<pin_writer<tMyType>>("out_default_1",
                                                   stream_type_default<>(oDescriptionForMyType));
 
// create the adtf::streaming::ISampleWriter* m_pWriter_2 instance
// i.e. by using CreateOutputPin overload take structure<> as parameter
m_pWriter_2 = CreateOutputPin("out_default_2", oDescriptionForMyType);
 
// create the adtf::streaming::ISampleWriter* m_pWriter_3 instance
// i.e. by using stream_type_default<T> creator function
// to use this method you MUST create <my_type.h> with MD Generator Tool to use tMyTypeWithMDGen
m_pWriter_3 = CreateOutputPin("out_default_2", stream_type_default<tMyTypeWithMDGen>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_defaults", cTimerTriggerHint(100));
 

Write Samples

Write the data with the help of pin_writer<T>::Write method or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner) override
{
    if (pRunner == m_pRunner)
    {
        tMyType sValues = {1, 2.0, {true, false}};
 
        // for pin_writer<T>
        // Write the value into a new sample with time of trigger 
        RETURN_IF_FAILED(m_pWriter_1->Write(tmTrigger, sValues));
 
        using namespace adtf::streaming; // to use output_sample_data<T>
        // for ISampleWriter
        // Write the value by creating an output_sample_data<T> with time of trigger
        *m_pWriter_2 << output_sample_data(tmTrigger, sValues);
 
        // for ISampleWriter with MD Generator Tool generated description <my_type.h>
        tMyTypeWithMDGen sValuesWithMDGen = {1, 2.0, {true, false}};
        // Write the value by creating an output_sample_data<T> with time of trigger
        *m_pWriter_3 << output_sample_data(tmTrigger, sValuesWithMDGen);
    }
 
    RETURN_NOERROR;
}

Input

Describe the expected input with stream_type_default

using namespace adtf::mediadescription; // to use stream_type_default<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// i.e. using stream_type_default<T> generator template
m_pReader_1 = CreateInputPin("in_default_1", stream_type_default<>(oDescriptionForMyType));
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// i.e. using CreateInputPin overload take structure<> as parameter
m_pReader_2 = CreateInputPin("in_default_2", oDescriptionForMyType);
 
// create the adtf::streaming::ISampleReader* m_pReader_3 instance
// i.e. by using stream_type_default<T> creator function
// to use this method you MUST create <my_type.h> with MD Generator Tool to use tMyTypeWithMDGen
m_pReader_3 = CreateInputPin("in_default_3", stream_type_default<tMyTypeWithMDGen>());
 

Read Samples

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
 
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content
        sample_data<tMyType> oSampleData(pSample);
 
        // i.e. access the values with operator*
        tMyType sValuesCopy = *oSampleData;
        // i.e. access the value with GetData()
        sValuesCopy = oSampleData.GetData();
    }
    // ... do the same for m_pReader_2
    // ...
    else if (pReader == m_pReader_3)
    {
        // use the sample_data<T> template to access the samples content
        sample_data<tMyTypeWithMDGen> oSampleData(pSample);
 
        // i.e. access the values with operator*
        tMyTypeWithMDGen sValuesCopy = *oSampleData;
        // i.e. access the value with GetData()
        sValuesCopy = oSampleData.GetData();
    }
    
 
    RETURN_NOERROR;
}

Array of structured data

Supported data types

The conditions to use an array of structured data as content of a sample is:

• The data type has to fulfill the condition of std::is_trivially_copyable<T>::value to be true
• No pointer types are allowed as member
• All members has to fullfill the condition of std::is_trivially_copyable<T>::value to be true

  // example structure that is trivially copyable
  struct tMyType
  {
      int32_t m_nValue1;
      double  m_fValue2;
      bool    m_bArray[2];
  };
   

  std::array<T, N>, where T is a supported structured data type (i.e. std::array<tMyType, 4> aValues;)
   
  T[N], where T is a supported structured data type (i.e. tMyType aValues[4];)

• It is also possible to define a DDL description file and use the generated type by MD Generator Tool.

   
  // this file is generated with MD Generator Tool
  #include <my_type.h>
   

Recommended Stream Type to use

Use the stream_type_default_array as instance of Stream Meta Type "adtf/default" for structured data. You are allowed to use every kind of your own Custom Stream Meta Types to describe the structured data you want to write. The advantage of using the stream_type_default_array is to describe the content by the help of the Data Definition Language (DDL). See also DDL and ADTF 3 how to create a description for your structured data. It will additionally handle the creation of the array type within description.

Output

Describe the data with stream_type_default_array

using namespace adtf::mediadescription; // to use stream_type_default_array<T>
using namespace adtf::filter; // to use pin_writer<T>
 
// i.e. we create a structure ddl description with the help of "type reflection"
auto oDescriptionForMyType = structure<tMyType>("tMyType")
                                 .Add("m_nValue1", &tMyType::m_nValue1)
                                 .Add("m_fValue2", &tMyType::m_fValue2)
                                 .Add("m_bArray", &tMyType::m_bArray);
 
// create the adtf::streaming::ISampleWriter* m_pWriter_1 instance
// by using stream_type_default_array<> generator template
m_pWriter_1 = CreateOutputPin("out_default_array_1",
                              stream_type_default_array<>(oDescriptionForMyType, 4));
 
// create the pin_writer<tMyType[4]>* m_pWriter_2 instance
// by using stream_type_default_array<> generator template
m_pWriter_2 = CreateOutputPin<pin_writer<tMyType[4]>>("out_default_array_2",
                              stream_type_default_array<>(oDescriptionForMyType, 4));
 
// create the adtf::streaming::ISampleWriter* m_pWriter_3 instance
// by using stream_type_default_array<T> generator template
// to use this method you MUST create <my_type.h> with MD Generator Tool to use type tMyTypeWithMDGen
m_pWriter_3 = CreateOutputPin("out_default_array_3", stream_type_default_array<tMyTypeWithMDGen[4]>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_default_arrays", cTimerTriggerHint(100));
 

Write Samples

Write the data with the help of pin_writer<T>::Write method or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner)
{
    if (pRunner == m_pRunner)
    {
        std::array<tMyType, 4> aStdArray = {tMyType{1, 2.0, {true, false}}, tMyType{2, 3.0, {false, false}},
                                            tMyType{3, 4.0, {true, true}}, tMyType{4, 5.0, {false, true}}};
 
        using namespace adtf::streaming; // to use output_sample_data<T>
        // for ISampleWriter*
        // write the value by creating output_sample_data<T> and set the time of trigger
        *m_pWriter_1 << output_sample_data(tmTrigger, aStdArray);
 
        // for pin_writer<T[N]>
        tMyType aValues[4] = {tMyType{1, 2.0, {true, false}}, tMyType{2, 3.0, {false, false}},
                              tMyType{3, 4.0, {true, true}}, tMyType{4, 5.0, {false, true}}};
        // use output_sample_data<T[N]>
        *m_pWriter_2 << output_sample_data(tmTrigger, aValues);
        // or use pin_writer<T>::Write method
        RETURN_IF_FAILED(m_pWriter_2->Write(tmTrigger, aValues));
 
        // for ISampleWriter*
        // write the value by creating output_sample_data<T> and set the time of trigger
        tMyTypeWithMDGen aValuesMDGen[4] = {tMyTypeWithMDGen{1, 2.0, {true, false}},
                                            tMyTypeWithMDGen{2, 3.0, {false, false}},
                                            tMyTypeWithMDGen{3, 4.0, {true, true}},
                                            tMyTypeWithMDGen{4, 5.0, {false, true}}};
        // use output_sample_data<T[N]>
        *m_pWriter_3 << output_sample_data(tmTrigger, aValuesMDGen);
    }
    RETURN_NOERROR;
}

Input

Describe the expected input with stream_type_default_array

using namespace adtf::mediadescription; // to use stream_type_default<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_default_array<> generator template
m_pReader_1 = CreateInputPin("in_default_array_1",
                             stream_type_default_array<>(oDescriptionForMyType, 4));
 
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// by using stream_type_default_array<> generator template
m_pReader_2 = CreateInputPin("in_default_array_2",
                             stream_type_default_array<>(oDescriptionForMyType, 4));
 
// create the adtf::streaming::ISampleReader* m_pReader_3 instance
// by using stream_type_default_array<T> generator template
// to use this method you MUST create <my_type.h> with MD Generator Tool to use type tMyTypeWithMDGen
m_pReader_3 = CreateInputPin("in_default_array_2",
                             stream_type_default_array<tMyTypeWithMDGen[4]>());
 

Read Samples

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content
        sample_data<std::array<tMyType, 4>> oSampleStdArrayData(pSample);
 
        // i.e. access the values with operator*
        std::array<tMyType, 4> aStdArrayCopy = *oSampleStdArrayData;
        // i.e. access the value with GetData()
        aStdArrayCopy = oSampleStdArrayData.GetData();
    }
    else if (pReader == m_pReader_2)
    {
        // for T[N]
        //   use the sample_data<T> template to access the samples content
        sample_data<tMyType[4]> oSampleArrayData(pSample);
 
        // i.e. access the values with operator*
        tMyType aValuesCopy[4];
        for (auto nIdx = 0; nIdx < 4; ++nIdx)
        {
            aValuesCopy[nIdx] = (*oSampleArrayData)[nIdx];
        }
 
        // i.e. access the value with GetData()
        for (auto nIdx = 0; nIdx < 4; ++nIdx)
        {
            aValuesCopy[nIdx] = oSampleArrayData.GetData()[nIdx];
        }
    }
    else if (pReader == m_pReader_3)
    {
        // for T[N]
        // use the sample_data<T> template to access the samples content
        sample_data<tMyTypeWithMDGen[4]> oSampleArrayData(pSample);
        // ...
    }
    RETURN_NOERROR;
}

Video types

Video image data

Supported type

A bitmap array of byte which can be described via tStreamImageFormat

Recommended Stream Type to use

Use the stream_type_image as instance of Stream Meta Type "adtf/image" for a sequence of images.

Output

Describe the data with stream_type_image

using namespace adtf::streaming; // to use stream_type_image<T>
 
// use a grey scale image (8bit)
tStreamImageFormat sFormat{stream_image_format::GREYSCALE_8::FormatName, 800, 600, 800 * 600};
 
// create the adtf::streaming::ISampleWriter* m_pWriter_1 instance
// i.e. by using stream_type_image<T> generator template
m_pWriter_1 = CreateOutputPin("out_video_1", stream_type_image(sFormat));
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_videos", cTimerTriggerHint(100));
 

Write Samples

Write the data with the help of operator<< for the sample

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner) override
{
    using namespace adtf::streaming; // to use alloc_sample, ISample, ISampleBuffer
 
    adtf::ucom::object_ptr<ISample> pSample;
    // use the current time of trigger for the sample
    RETURN_IF_FAILED(alloc_sample(pSample, tmTrigger));
 
    { // MIND: Before transmitting, the buffer must be unlocked!
        adtf::ucom::object_ptr_locked<ISampleBuffer> pSampleBuffer;
        RETURN_IF_FAILED(pSample->WriteLock(pSampleBuffer, 800 * 600)); // create a sample with 800*600*8Bit
        memset(pSampleBuffer->GetPtr(), pSampleBuffer->GetSize(), 0xF0); // this is an example set up a grey image
    
    } // this closure will unlock the buffer
 
    // write the sample
    *m_pWriter_1 << pSample;
 
    RETURN_NOERROR;
}

Input

Describe the expected input with stream_type_image

using namespace adtf::streaming; // to use stream_type_image<T> 
 
// accept a grey scale image (8bit)
tStreamImageFormat sFormat{stream_image_format::GREYSCALE_8::FormatName, 800, 600, 800*600};
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_image<T> generator template
m_pReader_1 = CreateInputPin("in_video_1", stream_type_image(sFormat));
 

Read Samples

Read the data directly from the sample

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use ISampleBuffer
 
    if (pReader == m_pReader_1)
    {
        // use the sample buffer to access the content
        adtf::ucom::object_ptr_shared_locked<const ISampleBuffer> pSampleBuffer;
        RETURN_IF_FAILED(pSample->Lock(pSampleBuffer));
 
        // check if the image is in the right size
        if (pSampleBuffer->GetSize() == 800 * 600)
        {
            const uint8_t* pPixels = static_cast<const uint8_t*>(pSampleBuffer->GetPtr());
            LOG_INFO("The 8Bit greyscale pixel[0] has following value: %d", int(pPixels[0]));
        }
        else
        {
            RETURN_ERROR_DESC(ERR_MEMORY, "The size of the image is not as expected 800*600*8Bit");
        }
    }
    // ... do the same for m_pReader_2
 
    RETURN_NOERROR;
}

Dynamic data in size

String data

Supported type

std::string
 
std::u16string

Recommended Stream Type to use

Use the stream_type_string as instance of Stream Meta Type "adtf/string" for string data.

Output for std::string

Describe the data with stream_type_string

using namespace adtf::streaming; // to use stream_type_string<T>
using namespace adtf::filter;    // to use pin_writer<T>
 
// create the adtf::filter::pin_writer<std::string>* m_pWriter_1 instance
// by using stream_type_string<T> generator template
m_pWriter_1 = CreateOutputPin<pin_writer<std::string>>("out_string_1",
                                                       stream_type_string<std::string>());
 
// create the adtf::filter::pin_writer<std::u16string>* m_pWriter_2 instance
// by using stream_type_string<T> generator template
m_pWriter_2 = CreateOutputPin<pin_writer<std::u16string>>("out_string_2",
                                                          stream_type_string<std::u16string>());
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_strings", cTimerTriggerHint(100));
 

Write Samples for std::string

Write the data with the help of operator<<

tResult Process(adtf::base::flash::tNanoSeconds tmTrigger, adtf::streaming::ant::IRunner* pRunner) override
{
    if (pRunner == m_pRunner)
    {
        std::string strStringToTransmit = "This is the output string";
        // for pin_writer<T>
        // write the value into a new sample with current time of trigger
        RETURN_IF_FAILED(m_pWriter_1->Write(tmTrigger, strStringToTransmit));
 
        std::u16string strU16StringToTransmit = u"This is the output u16string";
        // for pin_writer<T>
        // write the value into a new sample with current time of trigger
        RETURN_IF_FAILED(m_pWriter_2->Write(tmTrigger, strU16StringToTransmit));
    }
    RETURN_NOERROR;
}

Input for std::string

Describe the expected input with stream_type_string

using namespace adtf::streaming; // to use stream_type_string<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_string<T> generator template
m_pReader_1 = CreateInputPin("in_string_1", stream_type_string<std::string>());
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// by using stream_type_string<T> generator template
m_pReader_2 = CreateInputPin("in_string_2", stream_type_string<std::u16string>());
 

Read Samples for std::string

Read the data with the help of sample_data
Remark: An instance of sample_data will copy the buffers content of the sample to an instance of std::string

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
 
    if (pReader == m_pReader_1)
    {
        // use the sample_data<T> template to access the samples content as string
        sample_data<std::string> oSampleData(pSample);
 
        // i.e. access the values with operator*
        std::string strCopy = *oSampleData;
        // i.e. access the value with GetData()
        strCopy = oSampleData.GetData();
    }
    else if (pReader == m_pReader_2)
    {
        // use the sample_data<T> template to access the samples content as string
        sample_data<std::u16string> oSampleData(pSample);
 
        // i.e. access the values with operator*
        std::u16string strU16Copy = *oSampleData;
        // i.e. access the value with GetData()
        strU16Copy = oSampleData.GetData();
    }
 
    RETURN_NOERROR;
}

Dynamic arrays within structured data

Remarks

Please keep in mind, that this type is not supported within any displays by default!

Possible data types

The conditions to use an array of structured data with dynamic content within samples is:

• The structured data must be allocated in one whole block of memory.
• No pointer types are allowed as member
• All members except the flexible array member has to fullfill the condition of std::is_trivially_copyable<T>::value to be true
  REMARK: Dynamic memory allocations requires increased attention by the programmer!
  Since these conditions has to be met we recommend to use a static array and mark valid and invalid array positions.
  Dynamic content is mostly not supported by any ADTF standard display.

  // example structure that is a dynamic type
  // Mind: flexible array members must be always at the end of the structure!
  //       using this flexible array members always needs attention by the programmer!
  struct tMyTypeDynamic
  {
      uint64_t m_nArraySize;
      int32_t m_aDynamicArray[];
   
      static size_t EvaluateSize(size_t nArraySize)
      {
          return sizeof(struct tMyTypeDynamic) + nArraySize * sizeof(int32_t);
      }
  };
   
   

Recommended Stream Type to use

Use the stream_type_default as instance of Stream Meta Type "adtf/default" for structured data. The dynamic content can be described via arraysize within the DDL description.

Output

Describe the data with stream_type_default

using namespace adtf::mediadescription; // to use stream_type_default<T>
 
// i.e. we need to define the dynamic array in a description
constexpr auto strStructNameForMyTypeDynamic = "tMyTypeDynamic";
constexpr auto strDescriptionForMyTypeDynamic =
    R"(<struct name="tMyTypeDynamic" alignment="8" version="1">
      <element name="m_nArraySize" type="uint64_t" arraysize="1">
          <deserialized alignment="8"/>
          <serialized bytpos="0" byteorder="LE"/>
      </element>
      <element name="m_aDynamicArray" type="int32_t" arraysize="m_nArraySize">
          <deserialized alignment="4"/>
          <serialized bytpos="8" byteorder="LE"/>
      </element>
   </struct>)";
 
// create the adtf::streaming::ISampleWriter* m_pWriter instance
// by using stream_type_default<> generator template
m_pWriter_1 = CreateOutputPin("out_dynamic_1",
                              stream_type_default<>(strStructNameForMyTypeDynamic, strDescriptionForMyTypeDynamic));
 
// create the adtf::filter::pin_writer<tMyType>* m_pWriter_2 instance
// by using stream_type_default<> generator template
m_pWriter_2 = CreateOutputPin("out_default_2",
                              stream_type_default<>(strStructNameForMyTypeDynamic, strDescriptionForMyTypeDynamic));
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_dynamics", cTimerTriggerHint(100));
 

Write Samples

Write the data directly within samples memory

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner) override
{
    using namespace adtf::streaming; // to use alloc_sample
    if (pRunner == m_pRunner)
    {
        adtf::ucom::object_ptr<ISample> pSample;
        RETURN_IF_FAILED(alloc_sample(pSample, tmTrigger));
 
        { // MIND: pSampleBuffer must be unlocked before transmitting the sample!
            adtf::ucom::object_ptr_locked<ISampleBuffer> pSampleBuffer;
            RETURN_IF_FAILED(pSample->WriteLock(pSampleBuffer, tMyTypeDynamic::EvaluateSize(4)));
            tMyTypeDynamic* pMyDynamicArray = static_cast<tMyTypeDynamic*>(pSampleBuffer->GetPtr());
            pMyDynamicArray->m_nArraySize = 4; // this must be the same value as used in WriteLock call!
            for (auto nIdx = 0; nIdx < 4; ++nIdx)
            {
                pMyDynamicArray->m_aDynamicArray[nIdx] = nIdx;
            }
        } // this closure will unlock the pSampleBuffer
 
        // write the sample
        *m_pWriter_1 << pSample;
 
        // ... do the same for m_pWriter_2
    }
    RETURN_NOERROR;
}

Input

Describe the expected input with stream_type_default

using namespace adtf::mediadescription; // to use stream_type_default<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
// by using stream_type_default<> generator template
m_pReader_1 = CreateInputPin("in_default_1",
                             stream_type_default<>(strStructNameForMyTypeDynamic, strDescriptionForMyTypeDynamic));
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
// by using stream_type_default<> generator template
m_pReader_2 = CreateInputPin("in_default_2",
                             stream_type_default<>(strStructNameForMyTypeDynamic, strDescriptionForMyTypeDynamic));
 

Read Samples

Read the data directly from the samples buffer

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    using namespace adtf::streaming; // to acces the sample
 
    if (pReader == m_pReader_1)
    {
        adtf::ucom::object_ptr_shared_locked<const ISampleBuffer> pSampleBuffer;
        RETURN_IF_FAILED(pSample->Lock(pSampleBuffer));
 
        const tMyTypeDynamic* pMyArray = static_cast<const tMyTypeDynamic*>(pSampleBuffer->GetPtr());
        // we should check array size and expected sample buffer size
        if (tMyTypeDynamic::EvaluateSize(pMyArray->m_nArraySize) == pSampleBuffer->GetSize())
        {
            // i.e. access the value with GetData()
            LOG_INFO("The current array size is %zu", size_t(pMyArray->m_nArraySize));
        }
        else
        {
            RETURN_ERROR_DESC(ERR_MEMORY, "set dynamic array size and sample size does not fit!");
        }
    }
    //... do the same for m_pReader_2
 
    RETURN_NOERROR;
}

Custom data

You may define your own Meta Type to describe the data you want to transmit and receive. See also Custom Stream Meta Types.
The differences between the other ADTF standard data and the recommended stream types are:

• You can define own properties to describe the content
• You are able to implement an own my_custom_stream_meta_type::IsCompatible
• You can hide the content of the samples, because only you know the properties meanings
• As long as you not set the "md_struct" and "md_definition" property, you can not use any Standard Displays within ADTF

Example definition

struct my_custom_stream_meta_type
{
    // you must define the Metatype name as a variable "MetaTypeName"
    static constexpr const tChar* const MetaTypeName = "cppDev/my_custom_type";
 
    // this is a property to define a property name which identifies the content by the help of a number
    static constexpr const tChar* const SecretContentID = "secret_content_id";
    static constexpr const tChar* const Version = "version_of_type";
 
    static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        // we set the default values of the stream type
        pProperties->SetProperty(adtf::base::property<uint16_t>(SecretContentID, 0));
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(Version, "cppDev 2020-1.0"));
    }
};
 
struct my_custom_stream_type : public adtf::streaming::stream_type<my_custom_stream_meta_type>
{
    my_custom_stream_type()
    {
    }
    my_custom_stream_type(uint16_t nSecretContentNo)
    {
        adtf::ucom::object_ptr<adtf::base::IProperties> pConfig;
        THROW_IF_FAILED(GetConfig(pConfig));
        adtf::base::set_property<uint16_t>(*pConfig, my_custom_stream_meta_type::SecretContentID,
                                           nSecretContentNo);
    }
};
 
struct tMyCustomData1
{
    uint64_t nValue1;
    int64_t nValue2;
    uint32_t nValue3;
};
 
struct tMyCustomData2
{
    double nValue1;
    tMyCustomData1 aArrayData[3];
};

Output

Describe the data with your own meta type

using namespace adtf::filter;    // to use pin_writer<T>
 
// create the adtf::filter::pin_writer<std::string>* m_pWriter_1 instance
m_pWriter_1 = CreateOutputPin<pin_writer<tMyCustomData1>>("out_custom_1", my_custom_stream_type(1));
 
// create the adtf::streaming::ISampleWriter* m_pWriter_2 instance
m_pWriter_2 = CreateOutputPin("out_custom_2", my_custom_stream_type(2));
 
// create a adtf::streaming::IRunner to process every 100ms
m_pRunner = CreateRunner("write_customs", cTimerTriggerHint(100));
 

Write Samples

Write the samples with the operator<< or output_sample_data

tResult Process(adtf::base::tNanoSeconds tmTrigger, adtf::streaming::IRunner* pRunner) override
{
    if (pRunner == m_pRunner)
    {
        // for the pin_writer<tMyCustomData1>
        // write the value into a new sample with time of trigger
        m_pWriter_1->Write(tmTrigger, tMyCustomData1{1, 2, 3});
 
        // for ISampleWriter*
        // write the sample with the help of output_sample_data
        *m_pWriter_2 << adtf::streaming::output_sample_data(tmTrigger, tMyCustomData2{1.0, {{1, 2, 3}, {}, {}}});
    }
    RETURN_NOERROR;
}

Input

Describe the expected input with your own meta type

using namespace adtf::streaming; // to use stream_type_string<T>
 
// create the adtf::streaming::ISampleReader* m_pReader_1 instance
m_pReader_1 = CreateInputPin("in_custom_1", my_custom_stream_type(1));
 
// create the adtf::streaming::ISampleReader* m_pReader_2 instance
m_pReader_2 = CreateInputPin("in_custom_2", my_custom_stream_type(2));
 

Read Samples

Read the data with the help of sample_data

tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
                     const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override
{
    if (pReader == m_pReader_1)
    {
        using namespace adtf::streaming; // to use sample_data<T> for the incoming sample
 
        // use the sample_data<T> template to access the samples content
        sample_data<tMyCustomData1> oSampleData(pSample);
 
        // i.e. access the values with operator*
        tMyCustomData1 sCopyOfCustomData = *oSampleData;
        // i.e. access the value with GetData()
        sCopyOfCustomData = oSampleData.GetData();
    }
    // ... the same for m_pReader_2
    //     and sample_data<tMyCustomData2>
 
    RETURN_NOERROR;
}