imagedesc.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/sharedptr.h>
#include <promeki/size2d.h>
#include <promeki/pixelformat.h>
#include <promeki/metadata.h>
#include <promeki/enums.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class SdpMediaDescription;
 
class ImageDesc {
                PROMEKI_SHARED_FINAL(ImageDesc)
        public:
                using Ptr = SharedPtr<ImageDesc>;
 
                using List = ::promeki::List<ImageDesc>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                ImageDesc() {}
 
                ImageDesc(const Size2Du32 &sz, const PixelFormat &pd) : _size(sz), _pixelFormat(pd) {}
 
                ImageDesc(size_t w, size_t h, const PixelFormat &pd) : _size(Size2Du32(w, h)), _pixelFormat(pd) {}
 
                static ImageDesc fromSdp(const SdpMediaDescription &md);
 
                static PixelFormat::ID jpegPixelFormatFromSdp(const String &colorimetry, const String &range,
                                                              bool is420, bool isRgb);
 
                SdpMediaDescription toSdp(uint8_t payloadType) const;
 
                bool isValid() const { return _size.isValid() && _pixelFormat.isValid(); }
 
                const PixelFormat &pixelFormat() const { return _pixelFormat; }
 
                void setPixelFormat(const PixelFormat &pd) { _pixelFormat = pd; }
 
                const PixelMemLayout &memLayout() const { return _pixelFormat.memLayout(); }
 
                const ColorModel &colorModel() const { return _pixelFormat.colorModel(); }
 
                const Size2Du32 &size() const { return _size; }
 
                size_t width() const { return _size.width(); }
 
                size_t height() const { return _size.height(); }
 
                void setSize(const Size2Du32 &val) {
                        _size = val;
                        return;
                }
 
                void setSize(int width, int height) {
                        _size.set(width, height);
                        return;
                }
 
                size_t linePad() const { return _linePad; }
 
                void setLinePad(size_t val) {
                        _linePad = val;
                        return;
                }
 
                size_t lineAlign() const { return _lineAlign; }
 
                void setLineAlign(size_t val) {
                        _lineAlign = val;
                        return;
                }
 
                VideoScanMode videoScanMode() const { return _videoScanMode; }
 
                void setVideoScanMode(const VideoScanMode &mode) {
                        _videoScanMode = mode;
                        return;
                }
 
                const Metadata &metadata() const { return _metadata; }
 
                Metadata &metadata() { return _metadata; }
 
                int planeCount() const { return _pixelFormat.planeCount(); }
 
                String toString() const {
                        String ret = _size.toString();
                        if (_pixelFormat.isValid()) {
                                ret += ' ';
                                ret += _pixelFormat.name();
                        }
                        return ret;
                }
 
                operator String() const { return toString(); }
 
                bool operator==(const ImageDesc &other) const {
                        return formatEquals(other) && _metadata == other._metadata;
                }
 
                bool operator!=(const ImageDesc &other) const { return !(*this == other); }
 
                bool formatEquals(const ImageDesc &other) const {
                        return _size == other._size && _linePad == other._linePad && _lineAlign == other._lineAlign &&
                               _videoScanMode == other._videoScanMode && _pixelFormat == other._pixelFormat;
                }
 
        private:
                Size2Du32     _size;
                size_t        _linePad = 0;
                size_t        _lineAlign = 1;
                VideoScanMode _videoScanMode = VideoScanMode::Unknown;
                PixelFormat   _pixelFormat;
                Metadata      _metadata;
};
 
inline DataStream &operator<<(DataStream &stream, const ImageDesc &desc) {
        stream.beginFrame(DataTypeImageDesc, 1);
        stream << desc.size();
        stream << desc.pixelFormat();
        stream << static_cast<uint64_t>(desc.linePad());
        stream << static_cast<uint64_t>(desc.lineAlign());
        stream << static_cast<uint32_t>(desc.videoScanMode().value());
        stream << desc.metadata();
        stream.endFrame();
        return stream;
}
 
inline DataStream &operator>>(DataStream &stream, ImageDesc &desc) {
        if (!stream.readFrame(DataTypeImageDesc)) {
                desc = ImageDesc();
                return stream;
        }
        Size2Du32   size;
        PixelFormat pd;
        uint64_t    linePad = 0, lineAlign = 1;
        uint32_t    scanValue = 0;
        Metadata    meta;
        stream >> size >> pd >> linePad >> lineAlign >> scanValue >> meta;
        if (stream.status() != DataStream::Ok) {
                desc = ImageDesc();
                return stream;
        }
        desc = ImageDesc(size, pd);
        desc.setLinePad(static_cast<size_t>(linePad));
        desc.setLineAlign(static_cast<size_t>(lineAlign));
        desc.setVideoScanMode(VideoScanMode{static_cast<int>(scanValue)});
        desc.metadata() = std::move(meta);
        return stream;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::ImageDesc);
 
#endif // PROMEKI_ENABLE_PROAV