Example Substream Dumper

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Filter

Description

Shows how to access incoming substreams.

Prebuilt Binaries

• Substream Dumper

Source Code

./examples/demo_adtfplugins/substream_dumper/

Filter

substream_dumper_filter.cpp

 
#include "substream_dumper_filter.h"
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::mediadescription;
using namespace adtf::filter;
using namespace ddl;
 
cDemoSubStreamDumper::cDemoSubStreamDumper()
{
    // sets a short description for the component
    SetDescription("Use this filter to dump data of all samples of all available substreams.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_substream_dumper.html");
 
    m_pReader = CreateInputPin("input", stream_meta_type_substreams());
    SetDescription("input", "Incoming data of substreams for printing.");
 
    // Every filter that uses a substream input is required to request transmission of the substreams that it is interested in.
    // It will not receive any data otherwise! Non-interactive requests need to be performed within the following callback!
    m_pReader->SetSynchronousTypeUpdateCallback([&](const iobject_ptr<const IStreamType>& pStreamType) -> tResult
    {
        // this callback is called synchronously whenever the source changes the type and once when the connection is established.
        // Never use this callback to setup data structures to decode and/or access sample data, request handling is completely
        // independent of the data transmission. Use the AcceptType method instead.
 
        // first we clear all ongoing requests
        m_oRequests.clear();
 
        // and then request samples from all substreams
        stream_meta_type_substreams::ListSubStreams(*pStreamType.Get(), [&](const char* /*strName*/, uint32_t nSubStreamId)
        {
            object_ptr<IStreamingRequest> pRequest;
            THROW_IF_FAILED(m_pReader->RequestSamples(pRequest, nSubStreamId));
            // we store the request object for as long as we want those samples.
            m_oRequests.push_back(pRequest);
        });
 
        RETURN_NOERROR;
    });
}
 
cDemoSubStreamDumper::~cDemoSubStreamDumper() = default;
 
tResult cDemoSubStreamDumper::AcceptType(ISampleReader* pReader, const iobject_ptr<const IStreamType>& pStreamType)
{
    // let the base class do basic compatibility checks (i.e. if the stream meta type matches)
    RETURN_IF_FAILED(cFilter::AcceptType(pReader, pStreamType));
 
    // iterate over all available substreams.
    stream_meta_type_substreams::ListSubStreams(*pStreamType.Get(), [&](const char* strName, uint32_t nSubStreamId)
    {
        // first we try to generate a codec factory for the substream.
        auto pSubStreamType = stream_meta_type_substreams::GetSubStreamType(*pStreamType.Get(), strName);
        cSampleCodecFactory oCodecFactory(pSubStreamType);
 
        if (IS_OK(oCodecFactory.IsValid()))
        {
            m_oCodecFactories[nSubStreamId] = {oCodecFactory, strName};
        }
    });
 
    RETURN_NOERROR;
}
 
tResult cDemoSubStreamDumper::ProcessInput(ISampleReader* /*pReader*/, const iobject_ptr<const ISample>& pSample)
{
    // check the substreamid of the sample.
    auto itCodecFactory = m_oCodecFactories.find(get_sample_substream_id(pSample));
    if (itCodecFactory != m_oCodecFactories.end())
    {
        // and dump it with the matching decoder.
        auto oDecoder = itCodecFactory->second.oCodecFactory.MakeDecoderFor(pSample);
        LOG_INFO("Sample from %s:", itCodecFactory->second.strName.c_str());
        DumpSample(oDecoder);
    }
 
    RETURN_NOERROR;
}
 
void cDemoSubStreamDumper::DumpSample(const adtf::mediadescription::cSampleDecoder& oDecoder)
{
    adtf::mediadescription::for_each_leaf_element(oDecoder.GetElements(),
        [this](const adtf::mediadescription::cSampleDecoder::tElement& oElement) {
                                                      LOG_INFO("%s = %s",
                                                               oElement.getFullName().c_str(),
                                                               oElement.getStringValue().c_str());
        });
}
 
// this creates the plugin entry methods and class factories
ADTF_PLUGIN("Substream Dumper Plugin", cDemoSubStreamDumper);