include/fsdk/Types/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