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;
 
}
 
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;
};
 
}
 
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;
};
 
}
 
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;
 
}
}