streammetatypeaudio.h

Go to the documentation of this file.

 
#pragma once
#include <adtfbase/property_intf.h>
#include <adtfbase/property.h>
#include "streamtype.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);
    }
}
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());
}
 
inline ucom::ant::object_ptr<ant::IStreamType> create_adtf_audio_stream_type(const tStreamAudioFormat& sFormat)
{
    auto oCreatedType = create_adtf_audio_stream_type();
    THROW_IF_FAILED(set_stream_type_audio_format(*oCreatedType, sFormat));
    return oCreatedType;
}
 
} //namespace lucky
 
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;
 
}
}