hdrdynamic2094_40.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/buffer.h>
#include <promeki/error.h>
#include <promeki/json.h>
#include <promeki/list.h>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/string.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class HdrDynamic2094_40 {
        public:
                PROMEKI_DATATYPE(HdrDynamic2094_40, DataTypeHdrDynamic2094_40, 1)
 
                
                static constexpr uint8_t MaxWindows = 3;
 
                static constexpr uint8_t MaxDistributionPercentiles = 15;
 
                static constexpr uint8_t MaxBezierCurveAnchors = 15;
 
                static constexpr uint8_t InfoFrameType = 0x81;
 
                static constexpr uint8_t InfoFrameVersion = 1;
 
                static constexpr uint32_t HdrPlusOui = 0x90848B;
 
                struct Window {
                                uint16_t upperLeftCornerX = 0;
                                uint16_t upperLeftCornerY = 0;
                                uint16_t lowerRightCornerX = 0;
                                uint16_t lowerRightCornerY = 0;
                                uint16_t centerOfEllipseX = 0;
                                uint16_t centerOfEllipseY = 0;
                                uint8_t  rotationAngle = 0;
                                uint16_t semimajorAxisInternalEllipse = 0;
                                uint16_t semimajorAxisExternalEllipse = 0;
                                uint16_t semiminorAxisExternalEllipse = 0;
                                bool     overlapProcessOption = false;
 
                                bool operator==(const Window &o) const;
                                bool operator!=(const Window &o) const { return !(*this == o); }
                };
 
                struct ActualPeakLuminance {
                                uint8_t       numRows = 0; 
                                uint8_t       numCols = 0; 
                                List<uint8_t> values;      
 
                                bool isPresent() const { return numRows > 0 && numCols > 0; }
 
                                bool operator==(const ActualPeakLuminance &o) const;
                                bool operator!=(const ActualPeakLuminance &o) const { return !(*this == o); }
                };
 
                struct DistributionMaxRgb {
                                uint8_t  percentage = 0; 
                                uint32_t percentile = 0; 
 
                                bool operator==(const DistributionMaxRgb &o) const {
                                        return percentage == o.percentage && percentile == o.percentile;
                                }
                                bool operator!=(const DistributionMaxRgb &o) const { return !(*this == o); }
                };
 
                struct ToneMapping {
                                uint16_t       kneePointX = 0;       
                                uint16_t       kneePointY = 0;       
                                List<uint16_t> bezierCurveAnchors;   
 
                                bool operator==(const ToneMapping &o) const;
                                bool operator!=(const ToneMapping &o) const { return !(*this == o); }
                };
 
                struct WindowProcessing {
                                uint32_t                   maxScl[3] = {0, 0, 0}; 
                                uint32_t                   averageMaxRgb = 0;     
                                List<DistributionMaxRgb>   distribution;          
                                uint16_t                   fractionBrightPixels = 0; 
 
                                bool        hasToneMapping = false; 
                                ToneMapping toneMapping;            
 
                                bool    hasColorSaturationMapping = false; 
                                uint8_t colorSaturationWeight = 0;         
 
                                bool operator==(const WindowProcessing &o) const;
                                bool operator!=(const WindowProcessing &o) const { return !(*this == o); }
                };
 
                HdrDynamic2094_40();
 
                // -- Top-level field accessors -----------------------------
 
                uint8_t applicationVersion() const { return _applicationVersion; }
                void setApplicationVersion(uint8_t v) { _applicationVersion = v; }
 
                uint8_t numWindows() const { return _numWindows; }
 
                void setNumWindows(uint8_t n);
 
                const List<Window> &extraWindows() const { return _extraWindows; }
                List<Window> &extraWindows() { return _extraWindows; }
 
                uint32_t targetedSystemDisplayMaximumLuminance() const {
                        return _targetedSystemDisplayMaximumLuminance;
                }
                void setTargetedSystemDisplayMaximumLuminance(uint32_t v) {
                        _targetedSystemDisplayMaximumLuminance = v & 0x07FFFFFFu;
                }
 
                const ActualPeakLuminance &targetedSystemDisplayActualPeakLuminance() const {
                        return _targetedSystemDisplayActualPeakLuminance;
                }
                ActualPeakLuminance &targetedSystemDisplayActualPeakLuminance() {
                        return _targetedSystemDisplayActualPeakLuminance;
                }
 
                const List<WindowProcessing> &windowProcessing() const { return _windowProcessing; }
                List<WindowProcessing> &windowProcessing() { return _windowProcessing; }
 
                const ActualPeakLuminance &masteringDisplayActualPeakLuminance() const {
                        return _masteringDisplayActualPeakLuminance;
                }
                ActualPeakLuminance &masteringDisplayActualPeakLuminance() {
                        return _masteringDisplayActualPeakLuminance;
                }
 
                // -- Wire round-trip ---------------------------------------
 
                Buffer toBuffer() const;
 
                static Result<HdrDynamic2094_40> fromBuffer(const void *data, size_t size);
 
                static Result<HdrDynamic2094_40> fromBuffer(const Buffer &buf);
 
                // -- Inspection / debugging --------------------------------
 
                JsonObject toJson() const;
 
                bool operator==(const HdrDynamic2094_40 &o) const;
                bool operator!=(const HdrDynamic2094_40 &o) const { return !(*this == o); }
 
                String toString() const;
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<HdrDynamic2094_40> readFromStream(DataStream &s);
 
        private:
                uint8_t                _applicationVersion = 0;
                uint8_t                _numWindows = 1;
                List<Window>           _extraWindows;
                uint32_t               _targetedSystemDisplayMaximumLuminance = 0;
                ActualPeakLuminance    _targetedSystemDisplayActualPeakLuminance;
                List<WindowProcessing> _windowProcessing;
                ActualPeakLuminance    _masteringDisplayActualPeakLuminance;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV