Format.h

#pragma once
 
#include <cassert>
#include <cstring>
 
namespace fsdk {
 
    struct Format {
 
        enum Type {
            Unknown,
 
            B8G8R8X8,
 
            R8G8B8X8,
 
            B8G8R8,
 
            R8G8B8,
 
            R8,
 
            R16,
 
            IR_X8X8X8,
 
            YUV_NV21,
 
            YUV_NV12
        };
 
        const char* toString() const noexcept {
            switch(m_type) {
            case Type::B8G8R8X8:
                return "B8G8R8X8";
            case Type::R8G8B8X8:
                return "R8G8B8X8";
            case Type::B8G8R8:
                return "B8G8R8";
            case Type::R8G8B8:
                return "R8G8B8";
            case Type::R8:
                return "R8";
            case Type::R16:
                return "R16";
            case Type::IR_X8X8X8:
                return "IR_X8X8X8";
            case Type::YUV_NV21:
                return "YUV_NV21";
            case Type::YUV_NV12:
                return "YUV_NV12";
            default:
                return "Unknown";
            }
        }
 
        static Format fromString(const char* str) noexcept {
            if(strcmp(str, "B8G8R8X8") == 0) {
                return Format{Type::B8G8R8X8};
            } else if(strcmp(str, "R8G8B8X8") == 0) {
                return Format{Type::R8G8B8X8};
            } else if(strcmp(str, "B8G8R8") == 0) {
                return Format{Type::B8G8R8};
            } else if(strcmp(str, "R8G8B8") == 0) {
                return Format{Type::R8G8B8};
            } else if(strcmp(str, "R8") == 0) {
                return Format{Type::R8};
            } else if(strcmp(str, "R16") == 0) {
                return Format{Type::R16};
            } else if(strcmp(str, "IR_X8X8X8") == 0) {
                return Format{Type::IR_X8X8X8};
            } else if(strcmp(str, "YUV_NV21") == 0) {
                return Format{Type::YUV_NV21};
            } else if(strcmp(str, "YUV_NV12") == 0) {
                return Format{Type::YUV_NV12};
            } else {
                return Format{Type::Unknown};
            }
        }
 
        int getChannelCount() const noexcept {
            switch(m_type) {
            case B8G8R8X8:
            case R8G8B8X8:
            case B8G8R8:
            case R8G8B8:
            case IR_X8X8X8:
            case YUV_NV21:
            case YUV_NV12:
                return 3;
            case R8:
            case R16:
                return 1;
            default:
                return 0;
            }
        }
 
        int getChannelStep() const noexcept {
            switch(m_type) {
            case B8G8R8X8:
            case R8G8B8X8:
                return 4;
            case B8G8R8:
            case R8G8B8:
            case IR_X8X8X8:
                return 3;
            case R8:
            case R16:
            case YUV_NV21:
            case YUV_NV12:
                return 1;
            default:
                return 0;
            }
        }
 
        int getChannelSize() const noexcept {
            switch(m_type) {
            case B8G8R8X8:
            case R8G8B8X8:
            case B8G8R8:
            case R8G8B8:
            case IR_X8X8X8:
            case R8:
                return 8;
            case R16:
                return 16;
            case YUV_NV21:
            case YUV_NV12:
                return 12;
            default:
                return 0;
            }
        }
 
        int getBitDepth() const noexcept {
            return getChannelStep() * getChannelSize();
        }
 
        int getByteDepth() const noexcept {
            if(isBlock()) {
                assert(!"Not implemented");
                return 0;
            } else {
                return getBitDepth() >> 3;
            }
        }
 
        int computePitch(int rowWidth) const noexcept {
            return rowWidth * getByteDepth();
        }
 
        bool isPadded() const noexcept {
            switch(m_type) {
            case B8G8R8X8:
            case R8G8B8X8:
                return true;
            default:
                return false;
            }
        }
 
        bool isBGR() const noexcept {
            switch(m_type) {
            case B8G8R8X8:
            case B8G8R8:
                return true;
            default:
                return false;
            }
        }
 
        bool isYUV() const noexcept {
            switch(m_type) {
            case YUV_NV21:
            case YUV_NV12:
                return true;
            default:
                return false;
            }
        }
 
        bool isBlock() const noexcept {
            return false;
        }
 
        bool isValid() const noexcept {
            return m_type != Unknown;
        }
 
        Format() noexcept
            : m_type(Unknown) {
        }
 
        Format(Type type) noexcept
            : m_type(type) {
        }
 
        operator Type() const noexcept {
            return m_type;
        }
 
    protected:
        Type m_type; 
    };
 
    constexpr int format_as(Format::Type in) {
        return static_cast<int>(in);
    }
} // namespace fsdk