stream_type_default.h

Go to the documentation of this file.

 
#pragma once
 
#include "stream_meta_type_default.h"
#include "sample_codec.h"
#include "md_sample_data.h"
 
#include <adtfstreaming3/streamtype.h>
#include <type_traits>
#include <string_view>
 
namespace adtf
{
namespace mediadescription
{
namespace osborn
{
 
tResult set_media_description_properties(base::ant::IProperties& oProperties,
                                         const char* strStructName,
                                         const char* strMediaDescription,
                                         ddl::tDataRepresentation eRep = ddl::tDataRepresentation::Deserialized);
 
tResult set_media_description_properties(base::ant::IProperties& oProperties,
                                         const ddl::DDStructure& type_definition,
                                         ddl::tDataRepresentation eRep = ddl::tDataRepresentation::Deserialized);
 
tResult set_media_description_properties(base::ant::IProperties& oProperties,
                                         const std::pair<std::string, std::string>& type_definition,
                                         ddl::tDataRepresentation eRep = ddl::tDataRepresentation::Deserialized);
 
 
void set_stream_type_media_description(streaming::ant::IStreamType& oStreamType,
                                       const ddl::DDStructure& type_definition);
 
tResult set_stream_type_media_description(adtf::streaming::IStreamType& oStreamType,
                                          const char* strStructName,
                                          const char* strMediaDescription,
                                          ddl::tDataRepresentation eRep = ddl::tDataRepresentation::Deserialized);
 
tResult set_stream_type_media_description_from_service(adtf::streaming::IStreamType& oStreamType,
                                                       const char* strStructName,
                                                       ddl::tDataRepresentation eRep
                                                       = ddl::tDataRepresentation::Deserialized);
 
std::tuple<std::string, std::string, ddl::tDataRepresentation>
    get_media_description_from_stream_type(const adtf::streaming::IStreamType& oStreamType);
 
 
tResult get_codec_factory_from_stream_type(const adtf::streaming::IStreamType& oStreamType,
                                           cSampleCodecFactory& oFactory);
} // namespace osborn
 
namespace quiet
{
 
namespace detail
{
 
template<typename T> 
struct is_array_like: std::false_type {};
template<typename ValueType, size_t szArraySize>
struct is_array_like<std::array<ValueType, szArraySize>>: std::true_type {};
 
template<class ValueType, size_t szArraySize>
struct is_array_like<ValueType[szArraySize]>: std::true_type {};
 
template <typename T>
constexpr bool is_array_like_v = is_array_like<T>::value;
 
class cStreamTypeDefaultBase : public streaming::cStreamType
{
public:
    cStreamTypeDefaultBase(std::string_view strMDStructName,
                           std::string_view strMDDescription,
                           ddl::DataRepresentation eMDDataRepresentation,
                           size_t szFixArraySize,
                           bool bValidate = false);
 
    cStreamTypeDefaultBase(std::string_view strMDStructName,
                           ddl::DataRepresentation eMDDataRepresentation,
                           size_t szFixArraySize);
};
 
} // namespace detail
 
template<typename T = void>
class stream_type_default : public detail::cStreamTypeDefaultBase
{
public:
    static_assert(!std::is_arithmetic_v<T>,
                  "stream_type_default can be used only for structured types, "
                  "use adtf::streaming::stream_type_plain<T> instead");
    static_assert(std::is_trivially_copyable_v<T>,
                  "stream_type_default can be used only for trivial structured types");
    static_assert(!detail::is_array_like_v<T>,
                  "stream_type_default can not used for arrays of structured types, "
                  "use adtf::mediadescription::stream_type_default_array<T> instead");
    static_assert(has_description_v<T>,
                  "stream_type_default<T>() can only be used if ddl description was generated with adtf_mdgen! "
                  "If you have another source for the description, use stream_type_default<void>(...).");                      
 
    stream_type_default(): stream_type_default(ddl::DataRepresentation::deserialized)
    {
    }
    stream_type_default(ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(description<T>::name, description<T>::definition, eDataRep, 1)
    {
    }
};
 
template<>
class stream_type_default<void> : public detail::cStreamTypeDefaultBase
{
public:
    stream_type_default() = delete;
    stream_type_default(const ddl::DDStructure& oTypeDefinition):
        stream_type_default(oTypeDefinition, ddl::DataRepresentation::deserialized)
    {
    }
    stream_type_default(const ddl::DDStructure& oTypeDefinition,
                        ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(
            oTypeDefinition.getStructType().getName(), oTypeDefinition.getStructDescription(), eDataRep, 1)
    {
    }
 
    stream_type_default(std::string_view strMDStructName,
                        std::string_view strMDDescription):
        stream_type_default(strMDStructName, strMDDescription, ddl::DataRepresentation::deserialized)
    {
    }
 
    stream_type_default(std::string_view strMDStructName,
                        std::string_view strMDDescription,
                        ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(strMDStructName, strMDDescription, eDataRep, 1, true)
    {
    }
    stream_type_default(std::string_view strMDStructName):
        stream_type_default(strMDStructName, ddl::DataRepresentation::deserialized)
    {
    }
    stream_type_default(std::string_view strMDStructName,
                        ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(strMDStructName, eDataRep, 1)
    {
    }
};
 
/**********************************************************************************************/
/**********************************************************************************************/
 
template<typename T = void>
class stream_type_default_array
{
public:
    static_assert(adtf::base::penguin::detail::always_false<T>,
                  "stream_type_default_array can be used only for std::array<T, N> and T[N] "
                  "use i.e. adtf::mediadescription::stream_type_default_array<std::array<T, N>>! "
                  "Use stream_type_default_array<void> if you have a valid media description.");
};
 
template<>
class stream_type_default_array<void> : public detail::cStreamTypeDefaultBase
{
public:
    stream_type_default_array() = delete;
 
    stream_type_default_array(const ddl::DDStructure& oValueTypeDefinition,
                              size_t szArraySize):
        stream_type_default_array(oValueTypeDefinition, szArraySize, ddl::DataRepresentation::deserialized)
    {
    }
 
    stream_type_default_array(const ddl::DDStructure& oValueTypeDefinition,
                              size_t szArraySize,
                              ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(oValueTypeDefinition.getStructType().getName(),
                               oValueTypeDefinition.getStructDescription(),
                               eDataRep,
                               szArraySize)
    {
    }
 
    stream_type_default_array(std::string_view strMDStructName,
                              std::string_view strMDDescription,
                              size_t szArraySize):
        stream_type_default_array(strMDStructName, strMDDescription, szArraySize, ddl::DataRepresentation::deserialized)
    {
    }
 
    stream_type_default_array(std::string_view strMDStructName,
                              std::string_view strMDDescription,
                              size_t szArraySize,
                              ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(strMDStructName, strMDDescription, eDataRep, szArraySize, true)
    {
    }
 
    stream_type_default_array(std::string_view strMDStructName,
                              size_t szArraySize):
        stream_type_default_array(strMDStructName, szArraySize, ddl::DataRepresentation::deserialized)
    {
    }
 
    stream_type_default_array(std::string_view strMDStructName,
                              size_t szArraySize,
                              ddl::DataRepresentation eDataRep):
        cStreamTypeDefaultBase(strMDStructName, eDataRep, szArraySize)
    {
    }
};
 
template<class ValueType, size_t szArraySize>
class stream_type_default_array<ValueType[szArraySize]> : public stream_type_default_array<void>
{
public:
    static_assert(has_description_v<ValueType>,
                  "stream_type_default_array<T>() can only be used if ddl description was generated with adtf_mdgen! "
                  "If you have another source for the description, use stream_type_default_array<void>(...).");
    static_assert(!std::is_arithmetic_v<ValueType>,
                  "stream_type_default_array can be used only for structured types, "
                  "use adtf::streaming::stream_type_plain<std::array<T, N>> instead");
    static_assert(std::is_trivially_copyable_v<ValueType>,
                  "stream_type_default_array can be used only for trivial structured types");
 
    stream_type_default_array():
        stream_type_default_array(ddl::DataRepresentation::deserialized)
    {
    }
    stream_type_default_array(ddl::DataRepresentation eDataRep): 
        stream_type_default_array<void>(description<ValueType>::name, description<ValueType>::definition, szArraySize, eDataRep)
    {
    }
};
 
template<typename ValueType, size_t szArraySize>
class stream_type_default_array<std::array<ValueType, szArraySize>> : public stream_type_default_array<ValueType[szArraySize]>
{
public:
    using stream_type_default_array<ValueType[szArraySize]>::stream_type_default_array;
};
 
} // namespace quiet
 
using quiet::stream_type_default;
using quiet::stream_type_default_array;
 
using osborn::set_stream_type_media_description;
using osborn::set_stream_type_media_description_from_service;
using osborn::set_media_description_properties;
using osborn::get_codec_factory_from_stream_type;
 
using osborn::get_media_description_from_stream_type;
 
} //namespace mediadescription
} //namespace adtf