color.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Multimedia.
 *
 * StormByte-Multimedia original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Multimedia source in this
 * file. Third-party components — including FFmpeg and embedded trained data —
 * remain under their own licenses and are not covered by the commercial grant.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte-Multimedia is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with StormByte-Multimedia. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/multimedia/property/pixel_format.hxx>
#include <StormByte/multimedia/visibility.h>
 
namespace StormByte::Multimedia::Property {
    enum class STORMBYTE_MULTIMEDIA_PUBLIC Range {
        Unspecified,    
        TV,             
        Full,           
        Unknown         
    };
 
    enum class STORMBYTE_MULTIMEDIA_PUBLIC Space {
        Unspecified,            
        RGB,                    
        BT709,                  
        FCC,                    
        BT470BG,                
        SMPTE170M,              
        SMPTE240M,              
        YCgCo,                  
        BT2020NCL,              
        BT2020CL,               
        SMPTE2085,              
        ChromaDerivedNCL,       
        ChromaDerivedCL,        
        ICtCp,                  
        Unknown                 
    };
 
    enum class STORMBYTE_MULTIMEDIA_PUBLIC Primaries {
        Unspecified,    
        BT709,          
        BT470M,         
        BT470BG,        
        SMPTE170M,      
        SMPTE240M,      
        Film,           
        BT2020,         
        SMPTE428,       
        SMPTE431,       
        SMPTE432,       
        EBU3213,        
        Unknown         
    };
 
    enum class STORMBYTE_MULTIMEDIA_PUBLIC Transfer {
        Unspecified,    
        BT709,          
        Gamma22,        
        Gamma28,        
        SMPTE170M,      
        SMPTE240M,      
        Linear,         
        Log,            
        LogSqrt,        
        IEC61966_2_4,   
        BT1361,         
        IEC61966_2_1,   
        BT2020_10,      
        BT2020_12,      
        SMPTE2084,      
        SMPTE428,       
        ARIB_B67,       
        Unknown         
    };
 
    constexpr const char* ToString(Range range) noexcept {
        switch (range) {
            case Range::Unspecified:    return "Unspecified";
            case Range::TV:             return "TV";
            case Range::Full:           return "Full";
            case Range::Unknown:        return "Unknown";
            default:                    return "Invalid";
        }
    }
 
    constexpr const char* ToString(Space space) noexcept {
        switch (space) {
            case Space::Unspecified:        return "Unspecified";
            case Space::RGB:                return "RGB";
            case Space::BT709:              return "BT709";
            case Space::FCC:                return "FCC";
            case Space::BT470BG:            return "BT470BG";
            case Space::SMPTE170M:          return "SMPTE170M";
            case Space::SMPTE240M:          return "SMPTE240M";
            case Space::YCgCo:              return "YCgCo";
            case Space::BT2020NCL:          return "BT2020NCL";
            case Space::BT2020CL:           return "BT2020CL";
            case Space::SMPTE2085:          return "SMPTE2085";
            case Space::ChromaDerivedNCL:   return "ChromaDerivedNCL";
            case Space::ChromaDerivedCL:    return "ChromaDerivedCL";
            case Space::ICtCp:              return "ICtCp";
            case Space::Unknown:            return "Unknown";
            default:                        return "Invalid";
        }
    }
 
    constexpr const char* ToString(Primaries primaries) noexcept {
        switch (primaries) {
            case Primaries::Unspecified:    return "Unspecified";
            case Primaries::BT709:          return "BT709";
            case Primaries::BT470M:         return "BT470M";
            case Primaries::BT470BG:        return "BT470BG";
            case Primaries::SMPTE170M:      return "SMPTE170M";
            case Primaries::SMPTE240M:      return "SMPTE240M";
            case Primaries::Film:           return "Film";
            case Primaries::BT2020:         return "BT2020";
            case Primaries::SMPTE428:       return "SMPTE428";
            case Primaries::SMPTE431:       return "SMPTE431";
            case Primaries::SMPTE432:       return "SMPTE432";
            case Primaries::EBU3213:        return "EBU3213";
            case Primaries::Unknown:        return "Unknown";
            default:                        return "Invalid";
        }
    }
 
    constexpr const char* ToString(Transfer transfer) noexcept {
        switch (transfer) {
            case Transfer::Unspecified:     return "Unspecified";
            case Transfer::BT709:           return "BT709";
            case Transfer::Gamma22:         return "Gamma22";
            case Transfer::Gamma28:         return "Gamma28";
            case Transfer::SMPTE170M:       return "SMPTE170M";
            case Transfer::SMPTE240M:       return "SMPTE240M";
            case Transfer::Linear:          return "Linear";
            case Transfer::Log:             return "Log";
            case Transfer::LogSqrt:         return "LogSqrt";
            case Transfer::IEC61966_2_4:    return "IEC61966_2_4";
            case Transfer::BT1361:          return "BT1361";
            case Transfer::IEC61966_2_1:    return "IEC61966_2_1";
            case Transfer::BT2020_10:       return "BT2020_10";
            case Transfer::BT2020_12:       return "BT2020_12";
            case Transfer::SMPTE2084:       return "SMPTE2084";
            case Transfer::SMPTE428:        return "SMPTE428";
            case Transfer::ARIB_B67:        return "ARIB_B67";
            case Transfer::Unknown:         return "Unknown";
            default:                        return "Invalid";
        }
    }
 
    class STORMBYTE_MULTIMEDIA_PUBLIC Color final {
        public:
            Color(PixelFormat format, Range range, Space space, Primaries primaries, Transfer transfer) noexcept;
 
            Color(const Color&) = default;
 
            Color(Color&&) noexcept = default;
 
            ~Color() noexcept = default;
 
            Color& operator=(const Color&) = default;
 
            Color& operator=(Color&&) noexcept = default;
 
            PixelFormat PixelFormat() const noexcept;
 
            Range Range() const noexcept;
 
            Space Space() const noexcept;
 
            Primaries Primaries() const noexcept;
 
            Transfer Transfer() const noexcept;
 
            bool IsHDR10() const noexcept;
 
            bool IsHLG() const noexcept;
 
        private:
            enum PixelFormat m_format;      
            enum Range m_range;             
            enum Space m_space;             
            enum Primaries m_primaries;     
            enum Transfer m_transfer;       
    };
}