codec_sample_streamer.h

Go to the documentation of this file.

#pragma once
#include "sample_codec.h"
#include "media_description_type.h"
 
#ifdef USE_ADTF_MEDIA_DESCRIPTION_LEGACY
    #ifndef NO_ADTF_MEDIA_DESCRIPTION_LEGACY
        #include "legacy/codec_sample_streamer_legacy.h"
    #endif
#endif
 
#include <functional>
 
namespace adtf
{
namespace mediadescription
{
namespace osborn
{
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(cSampleDecoder& oDecoder)
    {
        base::flash::tNanoSeconds tmSampleTime;
        return GetNextDecoder(oDecoder, tmSampleTime);
    }

    bool GetNextDecoder(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(cSampleDecoder& oDecoder)
    {
        base::flash::tNanoSeconds tmSampleTime;
        return GetLastDecoder(oDecoder, tmSampleTime);
    }

    bool GetLastDecoder(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 cSampleCodec
{
public:
    cSampleWithCodec() = default;

    cSampleWithCodec(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());
    }
};
 
} // namespace osborn
 
using osborn::decoding_sample_reader;
using osborn::encoding_sample_writer;
 
} // namespace mediadescription
} // namespace adtf