streammetatypeimage.h

Go to the documentation of this file.

 
#pragma once
#include <adtfbase/property_intf.h>
#include <adtfbase/property.h>
#include "streamtype_intf.h"
#include "streamimageformat.h"
#include "streamtype.h"
 
#include <adtf_base_deprecated.h>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
 
struct stream_meta_type_image
{
    static constexpr const tChar *const MetaTypeName    = "adtf/image";
    static constexpr const tChar *const FormatName      = "format_name";
    static constexpr const tChar *const MaxByteSize     = "max_byte_size";
    static constexpr const tChar *const PixelWidth      = "pixel_width";
    static constexpr const tChar *const PixelHeight     = "pixel_height";
    static constexpr const tChar *const DataEndianess   = "data_endianess";
 
    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<uint32_t>(MaxByteSize, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(PixelWidth, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(PixelHeight, 0));
        pProperties->SetProperty(adtf::base::property<unsigned int>(DataEndianess, PLATFORM_BYTEORDER));
    }
};
tResult set_stream_type_image_format(IStreamType& oType, const tStreamImageFormat& oFormat);
 
tResult get_stream_type_image_format(tStreamImageFormat& oFormat, const IStreamType& oType);
 
} // namespace ant
 
namespace lucky
{
 
struct stream_meta_type_image : public ant::stream_meta_type_image
{
public:
    inline static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        ant::stream_meta_type_image::SetProperties(pProperties);
    }
    static tResult IsCompatible(const adtf::streaming::ant::IStreamType& oTypeToCheck,
                                const adtf::streaming::ant::IStreamType& oTypeExpected);
};
 
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_image<>>() instead!")
inline ucom::ant::object_ptr<ant::IStreamType> create_adtf_image_stream_type()
{
    return ucom::ant::make_object_ptr<ant::cStreamType>(lucky::stream_meta_type_image());
}
 
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_image<>>(const ant::tStreamImageFormat&) instead!")
inline ucom::ant::object_ptr<ant::IStreamType> create_adtf_image_stream_type(const ant::tStreamImageFormat& oFormat)
{
    auto oCreatedType = ucom::ant::make_object_ptr<ant::cStreamType>(lucky::stream_meta_type_image());
    THROW_IF_FAILED(ant::set_stream_type_image_format(*oCreatedType, oFormat));
    return oCreatedType;
}
 
} //namespace lucky
 
namespace penguin
{
template<typename T = ant::tStreamImageFormat>
class stream_type_image : public ant::cStreamType
{
    static_assert(std::is_same_v<ant::tStreamImageFormat, T>,
                  "Currently only T=ant::tStreamImageFormat is possible."
                  "To support your own type you need to specialize this template stream_type_image<T>");
 
public:
    stream_type_image():
        ant::cStreamType(lucky::stream_meta_type_image())
    {
    }
    stream_type_image(const T& sImageFormat):
        ant::cStreamType(lucky::stream_meta_type_image())
    {
        THROW_IF_FAILED(ant::set_stream_type_image_format(*this, sImageFormat));
    }
};
}
 
using lucky::stream_meta_type_image;
using ant::set_stream_type_image_format;
using ant::get_stream_type_image_format;
using lucky::create_adtf_image_stream_type;
using penguin::stream_type_image;
 
} // namespace streaming
} // namespace adtf