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/array.h>
#include <promeki/string.h>
#include <promeki/sharedptr.h>
#include <promeki/size2d.h>
#include <promeki/pixelformat.h>
#include <promeki/metadata.h>
#include <promeki/enums_video.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class SdpMediaDescription;
 
class ImageDesc {
                PROMEKI_SHARED_FINAL(ImageDesc)
        public:
                static constexpr size_t MaxPlanes = 4;
 
                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[0]; }
 
                size_t linePad(size_t plane) const { return plane < MaxPlanes ? _linePad[plane] : 0; }
 
                void setLinePad(size_t val) {
                        for (size_t p = 0; p < MaxPlanes; ++p) _linePad[p] = static_cast<uint32_t>(val);
                        return;
                }
 
                void setLinePad(size_t plane, size_t val) {
                        if (plane < MaxPlanes) _linePad[plane] = static_cast<uint32_t>(val);
                        return;
                }
 
                size_t lineAlign() const { return _lineAlign[0]; }
 
                size_t lineAlign(size_t plane) const { return plane < MaxPlanes ? _lineAlign[plane] : 1; }
 
                void setLineAlign(size_t val) {
                        for (size_t p = 0; p < MaxPlanes; ++p) _lineAlign[p] = static_cast<uint32_t>(val);
                        return;
                }
 
                void setLineAlign(size_t plane, size_t val) {
                        if (plane < MaxPlanes) _lineAlign[plane] = static_cast<uint32_t>(val);
                        return;
                }
 
                bool lineFlip(size_t plane = 0) const {
                        return plane < MaxPlanes && (_lineFlipMask & (1u << plane)) != 0;
                }
 
                void setLineFlip(bool val) {
                        _lineFlipMask = val ? static_cast<uint8_t>((1u << MaxPlanes) - 1) : 0;
                        return;
                }
 
                void setLineFlip(size_t plane, bool val) {
                        if (plane >= MaxPlanes) return;
                        if (val) _lineFlipMask |= static_cast<uint8_t>(1u << plane);
                        else _lineFlipMask &= static_cast<uint8_t>(~(1u << plane));
                        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 &&
                               _lineFlipMask == other._lineFlipMask && _videoScanMode == other._videoScanMode &&
                               _pixelFormat == other._pixelFormat;
                }
 
        private:
                Size2Du32                  _size;
                Array<uint32_t, MaxPlanes> _linePad{};               // 0 = tightly packed
                Array<uint32_t, MaxPlanes> _lineAlign{1, 1, 1, 1};   // 1 = no extra alignment
                uint8_t                    _lineFlipMask = 0;        // bit p set = plane p bottom-up
                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();
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p) stream << static_cast<uint32_t>(desc.linePad(p));
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p) stream << static_cast<uint32_t>(desc.lineAlign(p));
        uint32_t flipMask = 0;
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p)
                if (desc.lineFlip(p)) flipMask |= (1u << p);
        stream << flipMask;
        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;
        uint32_t    linePad[ImageDesc::MaxPlanes] = {0};
        uint32_t    lineAlign[ImageDesc::MaxPlanes] = {0};
        uint32_t    flipMask = 0;
        uint32_t    scanValue = 0;
        Metadata    meta;
        stream >> size >> pd;
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p) stream >> linePad[p];
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p) stream >> lineAlign[p];
        stream >> flipMask >> scanValue >> meta;
        if (stream.status() != DataStream::Ok) {
                desc = ImageDesc();
                return stream;
        }
        desc = ImageDesc(size, pd);
        for (size_t p = 0; p < ImageDesc::MaxPlanes; ++p) {
                desc.setLinePad(p, static_cast<size_t>(linePad[p]));
                desc.setLineAlign(p, static_cast<size_t>(lineAlign[p]));
                desc.setLineFlip(p, (flipMask & (1u << p)) != 0);
        }
        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