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

ADTF3_DEPRECATED("The ADTF Media Description Service is deprecated.")
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 ant
 
namespace flash
{

template <typename WRITER>
ADTF3_DEPRECATED("The ADTF Media Description Service is deprecated.")
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>
ADTF3_DEPRECATED("The ADTF Media Description Service is deprecated.")
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 flash
 
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);
 
} // namespace hollow
 
} // namespace mediadescription
 
} // namespace adtf