md_sample_data.h

Go to the documentation of this file.

#pragma once
 
#ifdef USE_ADTF_MEDIA_DESCRIPTION_LEGACY
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
        #include "legacy/md_sample_data_legacy.h"
    #endif
#endif
 
#include <adtfbase/adtf_base_type_traits.h>
#include <adtfbase/exception_handling.h>
#include <adtfmediadescription/sample_codec.h>
 
#include <memory>
#include <cstdint>
#include <string>
 
namespace adtf
{
namespace mediadescription
{
namespace osborn
{
namespace detail
{
 
template<typename, typename = void>
constexpr bool is_defined_v = false;
 
template<typename T>
constexpr bool is_defined_v<T, std::void_t<decltype(sizeof(T))>> = true;
 
} // namespace detail

template<typename T>
struct description;

template<typename T>
constexpr bool has_description_v = detail::is_defined_v<description<T>>;

template<typename T>
struct indices;

template<typename T>
class md_sample_data
{
public:
    md_sample_data()
    {
        static_assert(base::penguin::detail::always_false<T>,
                      "There is no md_sample_data specialization available for this type."
                      " Please make sure that you generate and include the corresponding header file.");
    }
};

template<typename T, typename UnderlyingType = T>
class md_array
{
public:
    md_array(const tCodecIndex aIndices[], std::shared_ptr<adtf::mediadescription::osborn::cSampleDecoder> pDecoder):
        m_pIndices(aIndices), m_pDecoder(pDecoder)
    {
    }
 
    T operator[](size_t nIndex) const
    {
        return static_cast<T>(m_pDecoder->template GetElementValue<UnderlyingType>(m_pIndices[nIndex]));
    }
 
private:
    const tCodecIndex* m_pIndices = nullptr;
    std::shared_ptr<adtf::mediadescription::osborn::cSampleDecoder> m_pDecoder;
};

template<typename T>
class md_struct_array
{
public:
    md_struct_array(const indices<T> aIndices[],
                    std::shared_ptr<adtf::mediadescription::osborn::cSampleDecoder> decoder):
        m_pIndices(aIndices), m_pDecoder(decoder)
    {
    }
 
    md_sample_data<T> operator[](size_t nIndex) const
    {
        return md_sample_data<T>(m_pIndices[nIndex], m_pDecoder);
    }
 
private:
    const indices<T>* m_pIndices = nullptr;
    std::shared_ptr<adtf::mediadescription::osborn::cSampleDecoder> m_pDecoder;
};

namespace detail
{
 
template<typename T>
struct decoder_with_indices : public cSampleDecoder
{
    decoder_with_indices(cSampleDecoder&& oDecoder, std::shared_ptr<indices<T>> pIndices):
        cSampleDecoder(std::move(oDecoder)), pIndices(std::move(pIndices))
    {
    }
 
    std::shared_ptr<indices<T>> pIndices;
};
 
} // namespace detail

template<typename T>
class md_sample_data_factory
{
public:
    static_assert(has_description_v<T>,
                  "md_sample_data_factory<T>() can only be used if ddl description was generated with adtf_mdgen!");
 
    /*
     * Default constructor that intializes the factory with the generated media description.
     */
    md_sample_data_factory(): md_sample_data_factory(description<T>::name, description<T>::definition)
    {
    }
 
    md_sample_data_factory(md_sample_data_factory&&) = default;
    md_sample_data_factory& operator=(md_sample_data_factory&&) = default;

    md_sample_data_factory(const adtf::ucom::ant::iobject_ptr<const adtf::streaming::IStreamType>& pStreamType):
        md_sample_data_factory(*pStreamType.Get())
    {
    }

    md_sample_data_factory(const adtf::streaming::IStreamType& oStreamType):
        m_oFactory(oStreamType), m_pIndices(std::make_shared<indices<T>>())
    {
        THROW_IF_FAILED(m_oFactory.IsValid());
        m_pIndices->Find(m_oFactory, "");
    }

    md_sample_data_factory(const char* strStructName, const char* strDefinition):
        m_oFactory(strStructName, strDefinition), m_pIndices(std::make_shared<indices<T>>())
    {
        THROW_IF_FAILED(m_oFactory.IsValid());
        m_pIndices->Find(m_oFactory, "");
    }

    md_sample_data<T> Make(const adtf::ucom::ant::iobject_ptr<const adtf::streaming::ant::ISample>& pSample)
    {
        return md_sample_data<T>(*m_pIndices, std::make_shared<detail::decoder_with_indices<T>>(
                                                  m_oFactory.MakeDecoderFor(pSample), m_pIndices));
    }
 
private:
    adtf::mediadescription::osborn::cSampleCodecFactory m_oFactory;
    std::shared_ptr<indices<T>> m_pIndices;
};
 
} // namespace osborn
 
using osborn::md_sample_data_factory;
using osborn::md_sample_data;
using osborn::description;
using osborn::has_description_v;
using osborn::md_array;
using osborn::md_struct_array;
 
} // namespace mediadescription
} // namespace adtf