streammetatypeaudio.h

Go to the documentation of this file.

#pragma once
#include <adtfbase/property_intf.h>
#include <adtfbase/property.h>
#include "streamtype.h"
 
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
 

struct stream_meta_type_audio
{
    static constexpr const tChar *const MetaTypeName = "adtf/audio";

    static constexpr const tChar *const FormatName = "format_name";
    static constexpr const tChar *const ChannelCount = "channel_count";
    static constexpr const tChar *const SampleRateHz = "sample_rate_hz";
    static constexpr const tChar *const BitsPerSample = "bits_per_sample";
    static constexpr const tChar *const SampleCount = "sample_count";

    static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(FormatName, ""));
        pProperties->SetProperty(adtf::base::property<unsigned int>(ChannelCount, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(SampleRateHz, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(BitsPerSample, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(SampleCount, 0));
    }
};
 
}
 
namespace lucky
{
struct tStreamAudioFormat
{
    adtf_util::cString m_strFormatName;
    unsigned int m_ui32ChannelCount = 0;
    unsigned int m_ui32SampleRateHz = 0;
    unsigned int m_ui32BitsPerSample = 0;
    unsigned int m_ui32SampleCount = 0;
};

inline bool operator==(const tStreamAudioFormat& oLeft, const tStreamAudioFormat& oRight)
{
    return (oLeft.m_strFormatName == oRight.m_strFormatName)
        && (oLeft.m_ui32BitsPerSample == oRight.m_ui32BitsPerSample)
        && (oLeft.m_ui32ChannelCount == oRight.m_ui32ChannelCount)
        && (oLeft.m_ui32SampleCount == oRight.m_ui32SampleCount)
        && (oLeft.m_ui32SampleRateHz == oRight.m_ui32SampleRateHz);
}

inline bool operator!=(const tStreamAudioFormat& oLeft, const tStreamAudioFormat& oRight)
{
    return !(oLeft == oRight);
}
 

inline tResult set_stream_type_audio_format(IStreamType& oType, const tStreamAudioFormat& sFormat)
{
    adtf_util::cString strMetaType;
    oType.GetMetaTypeName(adtf_string_intf(strMetaType));
    if (strMetaType == adtf::streaming::ant::stream_meta_type_audio::MetaTypeName)
    {
        set_property<adtf_util::cString>(oType, adtf::streaming::ant::stream_meta_type_audio::FormatName, sFormat.m_strFormatName);
        set_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::ChannelCount, sFormat.m_ui32ChannelCount);
        set_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::SampleRateHz, sFormat.m_ui32SampleRateHz);
        set_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::BitsPerSample, sFormat.m_ui32BitsPerSample);
        set_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::SampleCount, sFormat.m_ui32SampleCount);
        RETURN_NOERROR;
    }
    else
    {
        RETURN_ERROR(ERR_INVALID_TYPE);
    }
}

inline tResult get_stream_type_audio_format(tStreamAudioFormat& sFormat, const IStreamType& oType)
{
    adtf_util::cString strMetaType;
    oType.GetMetaTypeName(adtf_string_intf(strMetaType));
    if (strMetaType == adtf::streaming::ant::stream_meta_type_audio::MetaTypeName)
    {
        sFormat.m_strFormatName = get_property<adtf_util::cString>(oType, adtf::streaming::ant::stream_meta_type_audio::FormatName, "");
        sFormat.m_ui32ChannelCount = get_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::ChannelCount, 0);
        sFormat.m_ui32SampleRateHz = get_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::SampleRateHz, 0);
        sFormat.m_ui32BitsPerSample = get_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::BitsPerSample, 0);
        sFormat.m_ui32SampleCount = get_property<uint32_t>(oType, adtf::streaming::ant::stream_meta_type_audio::SampleCount, 0);
        RETURN_NOERROR;
    }
    else
    {
        RETURN_ERROR(ERR_INVALID_TYPE);
    }
}

ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_audio<>>() instead.")
inline ucom::ant::object_ptr<ant::IStreamType> create_adtf_audio_stream_type()
{
    return ucom::ant::make_object_ptr<adtf::streaming::ant::cStreamType>(adtf::streaming::ant::stream_meta_type_audio());
}

ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_audio<>>(const tStreamAudioFormat&) instead.")
inline ucom::ant::object_ptr<ant::IStreamType> create_adtf_audio_stream_type(const tStreamAudioFormat& sFormat)
{
    auto oCreatedType =
        ucom::ant::make_object_ptr<adtf::streaming::ant::cStreamType>(adtf::streaming::ant::stream_meta_type_audio());
    THROW_IF_FAILED(set_stream_type_audio_format(*oCreatedType, sFormat));
    return oCreatedType;
}
 
} //namespace lucky
 
namespace penguin
{
template<typename T = lucky::tStreamAudioFormat>
class stream_type_audio : public ant::cStreamType
{
    static_assert(std::is_same_v<lucky::tStreamAudioFormat, T>,
                  "Currently only T=lucky::tStreamAudioFormat is possible."
                  "To support your own type you need to specialize this template stream_type_audio<T>");
 
public:
    stream_type_audio():
        ant::cStreamType(ant::stream_meta_type_audio())
    {
    }
    stream_type_audio(const T& sAudioFormat):
        ant::cStreamType(ant::stream_meta_type_audio())
    {
        THROW_IF_FAILED(lucky::set_stream_type_audio_format(*this, sAudioFormat));
    }
};
} // namespace penguin
 
using ant::stream_meta_type_audio;
using lucky::tStreamAudioFormat;
using lucky::set_stream_type_audio_format;
using lucky::get_stream_type_audio_format;
using lucky::create_adtf_audio_stream_type;
using penguin::stream_type_audio;
 
}
}