cea708windowstate.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/array.h>
#include <promeki/buffer.h>
#include <promeki/cea708service.h>
#include <promeki/color.h>
#include <promeki/enums.h>
#include <promeki/list.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/subtitle.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct Cea708PenAttr {
                bool              italic = false;
                bool              underline = false;
                SubtitleEdgeStyle edgeStyle = SubtitleEdgeStyle::None;
                SubtitleFontFace  fontFace = SubtitleFontFace::Default;
                Color             foregroundColor;
                Color             backgroundColor;
                Color             edgeColor;
                SubtitleOpacity   foregroundOpacity = SubtitleOpacity::Solid;
                SubtitleOpacity   backgroundOpacity = SubtitleOpacity::Solid;
                SubtitleOpacity   edgeOpacity = SubtitleOpacity::Solid;
 
                bool hasAnyStyle() const {
                        return italic || underline
                                || edgeStyle.value() != SubtitleEdgeStyle::None.value()
                                || fontFace.value() != SubtitleFontFace::Default.value()
                                || foregroundColor.isValid() || backgroundColor.isValid()
                                || edgeColor.isValid()
                                || foregroundOpacity.value() != SubtitleOpacity::Solid.value()
                                || backgroundOpacity.value() != SubtitleOpacity::Solid.value()
                                || edgeOpacity.value() != SubtitleOpacity::Solid.value();
                }
 
                bool operator==(const Cea708PenAttr &o) const {
                        return italic == o.italic && underline == o.underline
                               && edgeStyle.value() == o.edgeStyle.value()
                               && fontFace.value() == o.fontFace.value()
                               && foregroundColor == o.foregroundColor
                               && backgroundColor == o.backgroundColor
                               && edgeColor == o.edgeColor
                               && foregroundOpacity.value() == o.foregroundOpacity.value()
                               && backgroundOpacity.value() == o.backgroundOpacity.value()
                               && edgeOpacity.value() == o.edgeOpacity.value();
                }
                bool operator!=(const Cea708PenAttr &o) const { return !(*this == o); }
};
 
struct Cea708WindowAttr {
                Color           fillColor;
                SubtitleOpacity fillOpacity = SubtitleOpacity::Solid;
 
                Color borderColor;
                uint8_t borderType = 0;
 
                uint8_t justify = 0;
                uint8_t printDirection = 0;
                uint8_t scrollDirection = 3; // BtT — caption convention
                bool wordWrap = false;
                uint8_t displayEffect = 0;
                uint8_t effectDirection = 0;
                uint8_t effectSpeed = 0;
 
                bool hasAnyAttribute() const {
                        return fillColor.isValid()
                               || fillOpacity.value() != SubtitleOpacity::Solid.value()
                               || borderColor.isValid()
                               || borderType != 0
                               || justify != 0
                               || printDirection != 0
                               || scrollDirection != 3
                               || wordWrap
                               || displayEffect != 0
                               || effectDirection != 0
                               || effectSpeed != 0;
                }
 
                bool operator==(const Cea708WindowAttr &o) const {
                        return fillColor == o.fillColor
                               && fillOpacity.value() == o.fillOpacity.value()
                               && borderColor == o.borderColor && borderType == o.borderType
                               && justify == o.justify && printDirection == o.printDirection
                               && scrollDirection == o.scrollDirection && wordWrap == o.wordWrap
                               && displayEffect == o.displayEffect && effectDirection == o.effectDirection
                               && effectSpeed == o.effectSpeed;
                }
                bool operator!=(const Cea708WindowAttr &o) const { return !(*this == o); }
};
 
struct Cea708Cell {
                uint32_t      codepoint = 0;
                Cea708PenAttr pen;
 
                bool operator==(const Cea708Cell &o) const {
                        return codepoint == o.codepoint && pen == o.pen;
                }
                bool operator!=(const Cea708Cell &o) const { return !(*this == o); }
};
 
struct Cea708Window {
                static constexpr int MaxRows = 15;
                static constexpr int MaxCols = 42;
 
                bool visible = false;       
                bool defined = false;       
                int  priority = 0;          
                int  anchorPoint = 1;       
                int  anchorV = 0;           
                int  anchorH = 0;           
                bool relativePos = true;    
                int  rowCount = 15;         
                int  colCount = 32;         
                bool rowLock = true;        
                bool colLock = true;        
                int  penRow = 0;            
                int  penCol = 0;            
 
                Cea708WindowAttr attrs;
 
                List<List<Cea708Cell>> grid;
 
                void resize(int rows, int cols);
 
                void clearGrid();
 
                void putChar(uint32_t cp, const Cea708PenAttr &pen);
 
                void putChar(uint32_t cp) { putChar(cp, Cea708PenAttr{}); }
 
                void carriageReturn();
 
                String text() const;
 
                SubtitleSpan::List visibleSpans() const;
 
                bool isEmpty() const;
 
                bool operator==(const Cea708Window &o) const;
                bool operator!=(const Cea708Window &o) const { return !(*this == o); }
};
 
class Cea708WindowState {
        public:
                static constexpr int WindowCount = 8;
 
                Cea708WindowState();
 
                void reset();
 
                int currentWindowId() const { return _currentWindow; }
                void setCurrentWindowId(int id) {
                        _currentWindow = (id < 0) ? 0 : (id > 7) ? 7 : id;
                }
 
                const Cea708Window &window(int id) const { return _windows[clampId(id)]; }
 
                Cea708Window &window(int id) { return _windows[clampId(id)]; }
 
                const Cea708Window &currentWindow() const { return _windows[_currentWindow]; }
                Cea708Window       &currentWindow() { return _windows[_currentWindow]; }
 
                const Cea708PenAttr &currentPen() const { return _pen; }
                Cea708PenAttr       &currentPen() { return _pen; }
 
                bool anyVisible() const;
 
                String visibleText() const;
 
                SubtitleSpan::List visibleSpans() const;
 
                void processServiceBytes(const Cea708Service &svc);
 
                void processBytes(const void *data, size_t size);
 
        private:
                using WindowArray = Array<Cea708Window, WindowCount>;
 
                WindowArray   _windows;
                int           _currentWindow = 0;
                Cea708PenAttr _pen;
 
                uint32_t _pendingHighSurrogate = 0;
 
                static int clampId(int id) {
                        if (id < 0) return 0;
                        if (id > 7) return 7;
                        return id;
                }
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV