Example Media Description Data Generator

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Filter

Description

Shows how to create samples provided by a DDL description file.

Prebuilt Binaries

• Media Description Data Generator

Source Code

./examples/demo_adtfplugins/media_description_data_generator/

Filter

demo_md_data_generator.h

 
#pragma once
 
#include <adtffiltersdk/filter.h>
#include <adtfmediadescription/codec_sample_streamer.h>
 
#include <random>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif
 
class cMediaDescriptionDataGenerator final : public adtf::filter::cFilter
{
public:
    ADTF_CLASS_ID_NAME(cMediaDescriptionDataGenerator,
                       "demo_media_description_data_generator.filter" ADTF_EXAMPLES_CID,
                       "Media Description Data Generator");

    cMediaDescriptionDataGenerator();
    ~cMediaDescriptionDataGenerator() override;

    tResult Init(tInitStage eStage) override;

    tResult Process(adtf::base::tNanoSeconds tmTimeOfTrigger, adtf::streaming::IRunner* pRunner) override;
 
private:
    adtf::base::property_variable<adtf::util::cString> m_strMediaDescriptionStructName;
    adtf::base::property_variable<adtf::util::cFilename> m_strDescriptionFile;
    adtf::base::property_variable<bool> m_bMarkSamplesAsDeserialized{true};
    adtf::mediadescription::encoding_sample_writer<>* m_pWriter;
 
    std::mt19937 m_oRandomGenerator;
    std::uniform_real_distribution<double> m_oDistribution;
};

demo_md_data_generator.cpp

 
#include "demo_md_data_generator.h"
#include <adtfddl/pkg_ddl.h>
 
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::filter;
using namespace adtf::mediadescription;
using namespace adtf::ucom;

ADTF_PLUGIN("Media Description Data Generator Plugin", cMediaDescriptionDataGenerator);
 
cMediaDescriptionDataGenerator::cMediaDescriptionDataGenerator(): m_oDistribution(0.0, 100.0)
{
    m_pWriter = CreateOutputPin<encoding_sample_writer<>>("data");
    SetDescription("data", "Provides the generated data based on the configured media description structure");
 
    CreateRunner("data_generator_function", cTimerTriggerHint(std::chrono::seconds{1}));
    SetDescription("data_generator_function",
                   "Runner to periodically trigger the function which generates the output samples");
 
    // for compatibility resons with older implementations we use the "data_generator_function" prefix.
    m_strMediaDescriptionStructName.SetDescription("The name of the DDL structure to generate.");
    RegisterPropertyVariable("data_generator_function/media_description_struct_name", m_strMediaDescriptionStructName);
 
    m_strDescriptionFile.SetDescription(
        "A description file containing the DDL description for the samples to generate.");
    RegisterPropertyVariable("description_file", m_strDescriptionFile);
 
    m_bMarkSamplesAsDeserialized.SetDescription(
        "Determines whether the data representation of the configured DDL description file is deserialized.");
    RegisterPropertyVariable("mark_samples_as_deserialized", m_bMarkSamplesAsDeserialized);
 
    // sets a short description for the component
    SetDescription("Use this filter to generate random values for a specified Media Description structure configured "
                   "by property 'media_description_struct_name'.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_media_description_data_generator.html");
}
 
cMediaDescriptionDataGenerator::~cMediaDescriptionDataGenerator() = default;
 
tResult cMediaDescriptionDataGenerator::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(cFilter::Init(eStage));
 
    if (eStage == StageNormal)
    {
        try
        {
            // import data definition from description file ..
            const auto oDataDefinition = ddl::DDFile::fromXMLFile(m_strDescriptionFile->GetPtr());
            // .. and create streamtype for configured struct type and data representation
            const object_ptr<IStreamType> pType = make_object_ptr<stream_type_default<>>(
                m_strMediaDescriptionStructName->GetPtr(), oDataDefinition,
                m_bMarkSamplesAsDeserialized ? ddl::tDataRepresentation::Deserialized :
                                               ddl::tDataRepresentation::Serialized);
 
            RETURN_IF_FAILED(m_pWriter->ChangeType(pType));
        }
        catch (...)
        {
            RETURN_CURRENT_EXCEPTION();
        }
    }
 
    RETURN_NOERROR;
}
 
tResult cMediaDescriptionDataGenerator::Process(tNanoSeconds tmTimeOfTrigger, IRunner* /*pRunner*/)
{
    // we use the same random value for all elements of the structure
    double fRandomValue = m_oDistribution(m_oRandomGenerator);
 
    auto oSample = m_pWriter->MakeSample(tmTimeOfTrigger);
 
    for_each_leaf_element(oSample.GetElements(), [&fRandomValue](auto& oElement) { oElement.setValue(fRandomValue); });
 
    m_pWriter->Write(oSample);
 
    RETURN_NOERROR;
}