codec_sample_streamer_legacy.h

Go to the documentation of this file.

 
#pragma once
#include "sample_codec_legacy.h"
#include "media_description_type_legacy.h"
 
#include <functional>
 
namespace adtf
{
 
namespace mediadescription
{
 
namespace flash
{
 
template <typename ReaderImplementation = streaming::flash::cDynamicSampleReader>
class decoding_sample_reader:
        public ReaderImplementation,
        public cSampleCodecFactory
{
    public:
        decoding_sample_reader()
        {
            ReaderImplementation::SetAcceptTypeCallback([&](const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType) -> tResult
            {
                static_cast<cSampleCodecFactory&>(*this) = cSampleCodecFactory();
                RETURN_IF_FAILED(get_codec_factory_from_stream_type(*pStreamType.Get(), *this));
 
                if (m_fnAcceptCallback)
                {
                    RETURN_IF_FAILED(m_fnAcceptCallback(pStreamType));
                }
                RETURN_NOERROR;
            });
        }
 
        tResult SetType(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType) override
        {
            RETURN_IF_FAILED(ReaderImplementation::SetType(pStreamType));
            // the initial type is not required to have a media description set
            static_cast<cSampleCodecFactory&>(*this) = cSampleCodecFactory();
            if (pStreamType.Get())
            {
                get_codec_factory_from_stream_type(*pStreamType.Get(), *this);
            }
            RETURN_NOERROR;
        }
 
        void SetAcceptTypeCallback(const std::function<tResult(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType)> & fnAcceptTypeCallback)
        {
            m_fnAcceptCallback = fnAcceptTypeCallback;
        }
 
        bool GetNextDecoder(ant::cSampleDecoder& oDecoder)
        {
            base::flash::tNanoSeconds tmSampleTime;
            return GetNextDecoder(oDecoder, tmSampleTime);
        }
 
        bool GetNextDecoder(ant::cSampleDecoder& oDecoder, base::flash::tNanoSeconds& tmSampleTime)
        {
            ucom::object_ptr<const streaming::ISample> pSample;
            auto oResult = ReaderImplementation::GetNextSample(pSample);
            if (IS_FAILED(oResult))
            {
                if (oResult == ERR_EMPTY)
                {
                    return false;
                }
                THROW_IF_FAILED(oResult);
            }
 
            oDecoder = MakeDecoderFor(pSample);
            THROW_IF_FAILED(oDecoder.IsValid());
            tmSampleTime = streaming::get_sample_time(pSample);
            return true;
        }
 
        bool GetLastDecoder(ant::cSampleDecoder& oDecoder)
        {
            base::flash::tNanoSeconds tmSampleTime;
            return GetLastDecoder(oDecoder, tmSampleTime);
        }
 
        bool GetLastDecoder(ant::cSampleDecoder& oDecoder, base::flash::tNanoSeconds& tmSampleTime)
        {
            ucom::object_ptr<const streaming::ISample> pSample;
            auto oResult = ReaderImplementation::GetLastSample(pSample);
            if (IS_FAILED(oResult))
            {
                if (oResult == ERR_EMPTY)
                {
                    return false;
                }
                THROW_IF_FAILED(oResult);
            }
 
            oDecoder = MakeDecoderFor(pSample);
            THROW_IF_FAILED(oDecoder.IsValid());
            tmSampleTime = streaming::get_sample_time(pSample);
            return true;
        }
 
    private:
        std::function<tResult(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType)> m_fnAcceptCallback;
};
 
class cSampleWithCodec: public ant::cSampleCodec
{
    public:
        cSampleWithCodec() = default;
 
        cSampleWithCodec(ant::cSampleCodec&& oCodec,
                         const ucom::ant::iobject_ptr<const streaming::ant::ISample>& pSample);
 
        cSampleWithCodec(cSampleWithCodec&&) = default;
        cSampleWithCodec& operator=(cSampleWithCodec&&) = default;
 
        virtual ~cSampleWithCodec();
 
        ucom::ant::object_ptr<const streaming::ant::ISample> Release();
 
    private:
        ucom::ant::object_ptr<const streaming::ant::ISample> m_pSample;
};
 
template <typename WriterImplementation = streaming::flash::cSampleWriter>
class encoding_sample_writer:
        public WriterImplementation,
        public cSampleCodecFactory
{
    public:
        cSampleWithCodec MakeSample(base::flash::tNanoSeconds tmTimeStamp)
        {
            ucom::object_ptr<streaming::ant::ISample> pSample;
            THROW_IF_FAILED(streaming::alloc_sample(pSample, tmTimeStamp));
            auto oCodec = MakeCodecFor(pSample);
            THROW_IF_FAILED(oCodec.IsValid());
            return cSampleWithCodec(std::move(oCodec), pSample);
        }
 
        tResult SetType(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType) override
        {
            RETURN_IF_FAILED(WriterImplementation::SetType(pStreamType));
            if (pStreamType.Get())
            {
                // the initial type is not required to have a media description set
                get_codec_factory_from_stream_type(*pStreamType.Get(), *this);
            }
            else
            {
                *static_cast<cSampleCodecFactory*>(this) = cSampleCodecFactory();
            }
            RETURN_NOERROR;
        }
 
        tResult ChangeType(const ucom::ant::iobject_ptr<const streaming::ant::IStreamType>& pStreamType) override
        {
            RETURN_IF_FAILED(WriterImplementation::ChangeType(pStreamType));
            // the initial type is not required to have a media description set
            get_codec_factory_from_stream_type(*pStreamType.Get(), *this);
            RETURN_NOERROR;
        }
 
        using WriterImplementation::Write;
 
        tResult Write(cSampleWithCodec& oSampleWithCodec)
        {
            return Write(oSampleWithCodec.Release());
        }
};
 
}
 
}
}