media_description_type_legacy.h

Go to the documentation of this file.

 
#pragma once
#include "sample_codec_legacy.h"
#include "type_reflection_legacy.h"
#include "md_sample_data_legacy.h"
 
#include <adtfstreaming3/streamtype_intf.h>
#include <adtfstreaming3/samplereader.h>
#include <adtfstreaming3/samplewriter.h>
#include <adtfmediadescription/stream_type_default.h>
 
#ifdef ADTF3_NO_DEPRECATED_WARNING
    #ifndef PKG_ADTF_DDL_NO_DEPRECATED_WARNING
        #define PKG_ADTF_DDL_NO_DEPRECATED_WARNING
    #endif
#endif
#include <pkg_ddl.h>
#include <utility>
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace mediadescription
{
namespace ant
{
 
ADTF3_DEPRECATED(
    "Use adtf::ucom::make_object_ptr<stream_type_default<>>(const char*, const char*, adtf_ddl::tDataRepresentation) "
    "instead!")
tResult create_adtf_default_stream_type(const char* strStructName, const char* strMediaDescription,
                                        ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType,
                                        adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
tResult create_adtf_default_stream_type(const char* strStructName, const char* strMediaDescription,
                                        ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType,
                                        cSampleCodecFactory& oFactory,
                                        adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_default<>>(const char*, adtf_ddl::tDataRepresentation) "
                 "instead!")
tResult create_adtf_default_stream_type_from_service(const char* strStructName,
                                                     ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType,
                                                     adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
tResult create_adtf_default_stream_type_from_service(const char* strStructName,
                                                     ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType,
                                                     cSampleCodecFactory& oFactory,
                                                     adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
tResult set_stream_type_media_description(adtf::streaming::IStreamType& oStreamType,
                                          const char* strStructName,
                                          const char* strMediaDescription,
                                          adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
tResult set_stream_type_media_description_from_service(adtf::streaming::IStreamType& oStreamType,
                                                       const char* strStructName,
                                                       adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
 
tResult get_codec_factory_from_stream_type(const adtf::streaming::IStreamType& oStreamType,
                                           cSampleCodecFactory& oFactory);
 
tResult add_stream_meta_type(const adtf::streaming::IStreamMetaType& oStreamTypeDef,
                             adtf_ddl::cDDLDescription& oDescription);
 
template <typename WRITER>
inline tResult make_sample_writer(WRITER& oWriter,
                                  const char* strNameOfWriter,
                                  const char* strDDLStructType)
{
    adtf::ucom::object_ptr<adtf::streaming::ant::IStreamType> pType;
    RETURN_IF_THROWS(pType = adtf::ucom::make_object_ptr<adtf::mediadescription::stream_type_default<>>(strDDLStructType));
    return adtf::streaming::ant::make_sample_writer(oWriter, strNameOfWriter, pType);
}
 
template <typename READER>
inline tResult make_sample_reader(READER& oReader,
                                  const char* strNameOfReader,
                                  const char* strDDLStructType)
{
    adtf::ucom::object_ptr<adtf::streaming::ant::IStreamType> pType;
    RETURN_IF_THROWS(pType = adtf::ucom::make_object_ptr<adtf::mediadescription::stream_type_default<>>(strDDLStructType));
    return adtf::streaming::ant::make_sample_reader(oReader, strNameOfReader, pType);
}
 
 
 
tResult get_stream_description_xml(const char* strName,
                                   const adtf::streaming::IStreamType& oStreamType,
                                   adtf::base::IString&& strDDLStream);
 
tResult create_stream_type_from_xml(const char* strXML,
                                    adtf::base::IString&& strName,
                                    ucom::iobject_ptr<adtf::streaming::IStreamType>& pStreamType);
 
tResult get_stream_description_xml(const std::vector<std::pair<adtf_util::cString,
                                                               const adtf::streaming::IStreamType*>> oStreams,
                                   adtf::base::IString&& strDDLStreams);
 
class cXercesInitializer
{
    public:
        cXercesInitializer() = default;
        ~cXercesInitializer() = default;
};
 
 
}
 
namespace flash
{
 
template <typename WRITER>
inline tResult make_sample_writer(WRITER& oWriter,
                                  const char* strNameOfWriter,
                                  const char* strDDLStructType)
{
    ucom::ant::object_ptr<adtf::streaming::ant::IStreamType> pType;
    RETURN_IF_THROWS(pType = adtf::ucom::make_object_ptr<adtf::mediadescription::stream_type_default<>>(strDDLStructType));
    return streaming::flash::make_sample_writer(oWriter, strNameOfWriter, pType);
}
 
template <typename READER>
inline tResult make_sample_reader(READER& oReader,
                                  const char* strNameOfReader,
                                  const char* strDDLStructType)
{
    ucom::ant::object_ptr<streaming::ant::IStreamType> pType;
    RETURN_IF_THROWS(pType = adtf::ucom::make_object_ptr<adtf::mediadescription::stream_type_default<>>(strDDLStructType));
    return streaming::flash::make_sample_reader(oReader, strNameOfReader, pType);
}
 
ucom::ant::object_ptr<streaming::ant::IStreamType> create_adtf_default_stream_type(const cStructureType& type_definition);
 
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_default<>>(const char*, const char*) instead!")
ucom::ant::object_ptr<streaming::ant::IStreamType> create_adtf_default_stream_type(const char* strStructName, const char* strMediaDescription);
 
template <typename Struct>
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_default<T>>() instead!")
ucom::ant::object_ptr<streaming::ant::IStreamType> create_adtf_default_stream_type()
{
    description<Struct>();
    return create_adtf_default_stream_type(description<Struct>::name,
                                           description<Struct>::definition);
}
 
tResult set_media_description_properties(base::ant::IProperties& oProperties,
                                         const char* strStructName,
                                         const char* strMediaDescription,
                                         adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
tResult set_media_description_properties(base::ant::IProperties& oProperties,
                                         const cStructureType& type_definition,
                                         adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
void set_stream_type_media_description(streaming::ant::IStreamType& oStreamType, const cStructureType& type_definition);
 
}
 
namespace hollow
{
 
std::tuple<std::string, std::string, adtf_ddl::tDataRepresentation> get_media_description_from_stream_type(const adtf::streaming::IStreamType& oStreamType);
 
ADTF3_DEPRECATED(
    "Use adtf::ucom::make_object_ptr<stream_type_default<>>(const char*, ddl::tDataRepresentation) instead!")
ucom::ant::object_ptr<streaming::ant::IStreamType> stream_type_from_service(const char* strStructName, adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized);
 
}
 
}
 
}