sample_codec_legacy.h

Go to the documentation of this file.

#pragma once
#include <adtfstreaming3/sample_intf.h>
#include <adtfstreaming3/streamtype_intf.h>
#include "type_reflection_legacy.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>
 
namespace adtf
{
namespace mediadescription
{
namespace ant
{
class cStaticSampleDecoder : public adtf_ddl::cStaticDecoder
{
public:
    cStaticSampleDecoder() = default;

    cStaticSampleDecoder(cStaticSampleDecoder&&) = default;
    cStaticSampleDecoder& operator=(cStaticSampleDecoder&&) = default;
 
private:
    friend class cSampleCodecFactory;
    cStaticSampleDecoder(adtf_ddl::cStaticDecoder&& oDecoder,
                         adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer>&& pBuffer):
        cStaticDecoder(std::move(oDecoder)), m_pBuffer(std::move(pBuffer))
    {
    }
 
private:
    adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer> m_pBuffer;
};

class cStaticSampleCodec : public adtf_ddl::cStaticCodec
{
public:
    cStaticSampleCodec() = default;

    cStaticSampleCodec(cStaticSampleCodec&&) = default;
    cStaticSampleCodec& operator=(cStaticSampleCodec&&) = default;
 
private:
    friend class cSampleCodecFactory;
    cStaticSampleCodec(adtf_ddl::cStaticCodec&& oCodec,
                       adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer>&& pBuffer):
        cStaticCodec(std::move(oCodec)), m_pBuffer(std::move(pBuffer))
    {
    }
 
private:
    adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer> m_pBuffer;
};

class cSampleDecoder : public adtf_ddl::cDecoder
{
public:
    cSampleDecoder() = default;

    cSampleDecoder(cSampleDecoder&&) = default;
    cSampleDecoder& operator=(cSampleDecoder&&) = default;
 
    using adtf_ddl::cDecoder::GetElementValue;
    adtf::util::cVariant GetElementValue(size_t nElementIndex) const;
    adtf::util::cVariant GetElementValue(const char* strElementName) const;
    adtf::util::cString GetElementValueString(size_t nElementIndex) const;
    adtf::util::cString GetElementValueString(const char* strElementName) const;
 
    using adtf_ddl::cDecoder::GetElement;
    const adtf_ddl::tStructElement& GetElement(size_t nElementIndex) const;
 
private:
    friend class cSampleCodecFactory;
    cSampleDecoder(adtf_ddl::cDecoder&& oDecoder,
                   adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer>&& pBuffer):
        cDecoder(std::move(oDecoder)), m_pBuffer(std::move(pBuffer))
    {
    }
 
private:
    adtf::ucom::object_ptr_shared_locked<const adtf::streaming::ISampleBuffer> m_pBuffer;
};

class cSampleCodec : public adtf_ddl::cCodec
{
public:
    cSampleCodec() = default;

    cSampleCodec(cSampleCodec&&) = default;
    cSampleCodec& operator=(cSampleCodec&&) = default;
 
    using adtf_ddl::cCodec::SetElementValue;
    void SetElementValue(const char* strElementName, const adtf::util::cVariant& oValue);
 
private:
    friend class cSampleCodecFactory;
    cSampleCodec(adtf_ddl::cCodec&& oCodec, adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer>&& pBuffer):
        cCodec(std::move(oCodec)), m_pBuffer(std::move(pBuffer))
    {
    }
 
private:
    adtf::ucom::object_ptr_locked<adtf::streaming::ISampleBuffer> m_pBuffer;
};

class cSampleCodecFactory
{
public:
    cSampleCodecFactory() = default;

    cSampleCodecFactory(
        const char* strStructName,
        const char* strMediaDescription,
        adtf_ddl::tDataRepresentation eDefaultDataRepresentation = adtf_ddl::tDataRepresentation::Deserialized);
    cSampleCodecFactory(
        const adtf_ddl::cDDLComplex* pStruct,
        adtf_ddl::tDataRepresentation eDefaultDataRepresentation = adtf_ddl::tDataRepresentation::Deserialized);

    cSampleCodecFactory(cSampleCodecFactory&) = default;
 
#ifndef WIN32
    // the missing const above was an oversight and lead to problems with older GCCs when storing
    // cSampleCodecFactory in STL containers and pairs.
    cSampleCodecFactory(const cSampleCodecFactory&) = default;
#endif

    cSampleCodecFactory(cSampleCodecFactory&&) = default;

    cSampleCodecFactory& operator=(cSampleCodecFactory&) = default;

    cSampleCodecFactory& operator=(cSampleCodecFactory&&) = default;

    tResult IsValid() const;

    cStaticSampleDecoder MakeStaticDecoderFor(const adtf::streaming::ISample& oSample,
                                              adtf_ddl::tDataRepresentation eDataRepresentation) const;

    cStaticSampleCodec MakeStaticCodecFor(adtf::streaming::ISample& oSample,
                                          adtf_ddl::tDataRepresentation eDataRepresentation) const;

    cSampleDecoder MakeDecoderFor(const adtf::streaming::ISample& oSample,
                                  adtf_ddl::tDataRepresentation eDataRepresentation) const;

    cSampleCodec MakeCodecFor(adtf::streaming::ISample& oSample,
                              adtf_ddl::tDataRepresentation eDataRepresentation) const;

    size_t GetStaticElementCount() const;

    tResult GetStaticElement(size_t nIndex, const adtf_ddl::tStructElement*& pElement) const;

    size_t GetStaticBufferSize(adtf_ddl::tDataRepresentation eRep = adtf_ddl::tDataRepresentation::Deserialized) const;

    adtf_ddl::tDataRepresentation GetDefaultDataRepresentation() const;
 
public: // convenience methods
    inline cStaticSampleDecoder
        MakeStaticDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample,
                             adtf_ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeStaticDecoderFor(*pSample.Get(), eDataRepresentation);
    }

    inline cSampleDecoder MakeDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample,
                                         adtf_ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeDecoderFor(*pSample.Get(), eDataRepresentation);
    }

    inline cStaticSampleCodec MakeStaticCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample,
                                                 adtf_ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeStaticCodecFor(*pSample.Get(), eDataRepresentation);
    }

    inline cSampleCodec MakeCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample,
                                     adtf_ddl::tDataRepresentation eDataRepresentation) const
    {
        return MakeCodecFor(*pSample.Get(), eDataRepresentation);
    }

    inline cStaticSampleDecoder
        MakeStaticDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) const
    {
        return MakeStaticDecoderFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }

    inline cSampleDecoder MakeDecoderFor(const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) const
    {
        return MakeDecoderFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }

    inline cStaticSampleCodec MakeStaticCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample) const
    {
        return MakeStaticCodecFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }

    inline cSampleCodec MakeCodecFor(const adtf::ucom::iobject_ptr<adtf::streaming::ISample>& pSample) const
    {
        return MakeCodecFor(*pSample.Get(), m_eDefaultDataRepresentation);
    }

    inline cStaticSampleDecoder MakeStaticDecoderFor(const adtf::streaming::ISample& oSample) const
    {
        return MakeStaticDecoderFor(oSample, m_eDefaultDataRepresentation);
    }

    inline cSampleDecoder MakeDecoderFor(const adtf::streaming::ISample& oSample) const
    {
        return MakeDecoderFor(oSample, m_eDefaultDataRepresentation);
    }

    inline cStaticSampleCodec MakeStaticCodecFor(adtf::streaming::ISample& oSample) const
    {
        return MakeStaticCodecFor(oSample, m_eDefaultDataRepresentation);
    }

    inline cSampleCodec MakeCodecFor(adtf::streaming::ISample& oSample) const
    {
        return MakeCodecFor(oSample, m_eDefaultDataRepresentation);
    }
 
private:
    adtf_ddl::cCodecFactory m_oFactory;
    adtf_ddl::tDataRepresentation m_eDefaultDataRepresentation;
};
 
} // namespace ant
 
namespace flash
{
class cSampleCodecFactory : public ant::cSampleCodecFactory
{
public:
    typedef adtf_ddl::tStructElement DefinedStructElementType;
 
    cSampleCodecFactory() = default;
    using ant::cSampleCodecFactory::cSampleCodecFactory;
 
    cSampleCodecFactory(const cStructureType& oTypeDefinition);
    cSampleCodecFactory(const streaming::ant::IStreamType& oStreamType);
    cSampleCodecFactory(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType);
 
    size_t FindIndex(const char* strElementName) const;
    size_t FindArrayIndex(const char* strArrayName) const;
    size_t FindStructIndex(const char* strStructName) const;
 
    using ant::cSampleCodecFactory::GetStaticElement;
    const adtf_ddl::tStructElement& GetStaticElement(size_t nElementIndex) const;
    static const char* GetStaticStructElementName(const adtf_ddl::tStructElement* pElement);
};
 
} // namespace flash
 
namespace adtf_ddl_legacy
{
using flash::cType;
using flash::cEnumerationType;
using flash::enumeration;
using flash::cStructureType;
using flash::structure;
 
using ant::cStaticSampleDecoder;
using ant::cStaticSampleCodec;
using ant::cSampleDecoder;
using ant::cSampleCodec;
using flash::cSampleCodecFactory;
} // namespace adtf_ddl_legacy
} // namespace mediadescription
} // namespace adtf