md_sample_data_legacy.h

Go to the documentation of this file.

#pragma once
#include <adtfbase/adtf_base_type_traits.h>
#include <adtfbase/exception_handling.h>
#include "sample_codec_legacy.h"
 
#include <memory>
#include <cstdint>
#include <string>
 
namespace adtf
{
namespace mediadescription
{
namespace flash
{

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

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 size_t aIndices[],
                 std::shared_ptr<adtf::mediadescription::ant::cSampleDecoder> pDecoder):
            m_pIndices(aIndices),
            m_pDecoder(pDecoder)
        {
        }
 
        T operator[](size_t nIndex) const
        {
            return static_cast<T>(static_cast<UnderlyingType>(m_pDecoder->GetElementValue(m_pIndices[nIndex])));
        }
 
    private:
        const size_t* m_pIndices = nullptr;
        std::shared_ptr<adtf::mediadescription::ant::cSampleDecoder> m_pDecoder;
};

template <typename T>
class md_struct_array
{
    public:
        md_struct_array(const indices<T> aIndices[],
                        std::shared_ptr<adtf::mediadescription::ant::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::ant::cSampleDecoder> m_pDecoder;
};

namespace detail
{
 
template <typename T>
struct decoder_with_indices: public ant::cSampleDecoder
{
    decoder_with_indices(ant::cSampleDecoder&& oDecoder,
                        std::shared_ptr<indices<T>> pIndices):
        ant::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:
        /*
         * 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::flash::cSampleCodecFactory m_oFactory;
        std::shared_ptr<indices<T>> m_pIndices;
};
 
}
 
}
}