cea608.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/color.h>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct Cea608 {
                // -- Odd parity ---------------------------------------------
 
                static constexpr uint8_t withOddParity(uint8_t c) {
                        uint8_t v = static_cast<uint8_t>(c & 0x7F);
                        unsigned ones = 0;
                        for (int i = 0; i < 7; ++i) {
                                if (v & (1u << i)) ++ones;
                        }
                        if ((ones & 1u) == 0u) v = static_cast<uint8_t>(v | 0x80);
                        return v;
                }
 
                static constexpr bool checkOddParity(uint8_t c) {
                        unsigned ones = 0;
                        for (int i = 0; i < 8; ++i) {
                                if (c & (1u << i)) ++ones;
                        }
                        return (ones & 1u) != 0u;
                }
 
                static constexpr uint8_t stripParity(uint8_t c) { return static_cast<uint8_t>(c & 0x7F); }
 
                static constexpr bool checkOddParityPair(uint8_t b1, uint8_t b2) {
                        return checkOddParity(b1) && checkOddParity(b2);
                }
 
                // -- Channel selectors (pre-parity first-byte values) -------
 
                enum class Channel : uint8_t {
                        CC1 = 0, 
                        CC2 = 1, 
                        CC3 = 2, 
                        CC4 = 3, 
                };
 
                static constexpr bool isSecondChannelOfField(Channel ch) {
                        return ch == Channel::CC2 || ch == Channel::CC4;
                }
 
                static constexpr bool isFieldTwo(Channel ch) {
                        return ch == Channel::CC3 || ch == Channel::CC4;
                }
 
                static constexpr uint8_t Cc1MiscFirstByte = 0x14;
 
                // -- Misc control codes (second-byte values) ----------------
 
                static constexpr uint8_t MiscRCL = 0x20; 
                static constexpr uint8_t MiscBS  = 0x21; 
                static constexpr uint8_t MiscDER = 0x24; 
                static constexpr uint8_t MiscRU2 = 0x25; 
                static constexpr uint8_t MiscRU3 = 0x26; 
                static constexpr uint8_t MiscRU4 = 0x27; 
                static constexpr uint8_t MiscFON = 0x28; 
                static constexpr uint8_t MiscRDC = 0x29; 
                static constexpr uint8_t MiscTR  = 0x2A; 
                static constexpr uint8_t MiscRTD = 0x2B; 
                static constexpr uint8_t MiscEDM = 0x2C; 
                static constexpr uint8_t MiscCR  = 0x2D; 
                static constexpr uint8_t MiscENM = 0x2E; 
                static constexpr uint8_t MiscEOC = 0x2F; 
 
                // -- Convenience: pre-parity (b1, b2) for CC1 control pairs --
 
                static constexpr uint8_t RclB1 = Cc1MiscFirstByte;
                static constexpr uint8_t RclB2 = MiscRCL;
 
                static constexpr uint8_t EocB1 = Cc1MiscFirstByte;
                static constexpr uint8_t EocB2 = MiscEOC;
 
                static constexpr uint8_t EdmB1 = Cc1MiscFirstByte;
                static constexpr uint8_t EdmB2 = MiscEDM;
 
                static constexpr uint8_t EnmB1 = Cc1MiscFirstByte;
                static constexpr uint8_t EnmB2 = MiscENM;
 
                // -- PAC (Preamble Address Code) ----------------------------
 
                static constexpr uint8_t PacRow15Col0WhiteB1 = 0x14;
                static constexpr uint8_t PacRow15Col0WhiteB2 = 0x70;
 
                // -- CEA-608 colour palette ---------------------------------
 
                enum class CaptionColor : uint8_t {
                        White   = 0,
                        Green   = 1,
                        Blue    = 2,
                        Cyan    = 3,
                        Red     = 4,
                        Yellow  = 5,
                        Magenta = 6,
                        Black   = 7, 
                };
 
                static constexpr size_t CaptionColorCount = 8;
 
                static constexpr size_t FgCaptionColorCount = 7;
 
                static Color::List palette();
 
                struct PacAttr {
                                int row = 15;
                                int indentCol = 0;
                                CaptionColor color = CaptionColor::White;
                                bool italic = false;
                                bool underline = false;
                };
 
                static void encodePac(const PacAttr &attr, uint8_t &b1, uint8_t &b2);
 
                static bool isPac(uint8_t b1, uint8_t b2);
 
                static bool decodePac(uint8_t b1, uint8_t b2, PacAttr &out);
 
                // -- Mid-row codes ------------------------------------------
 
                static void encodeMidRow(CaptionColor color, bool italic, bool underline, uint8_t &b1,
                                         uint8_t &b2);
 
                static bool isMidRow(uint8_t b1, uint8_t b2);
 
                static bool decodeMidRow(uint8_t b1, uint8_t b2, CaptionColor &outColor, bool &outItalic,
                                         bool &outUnderline);
 
                // -- Background attribute codes -----------------------------
                //
                // Background attribute codes (CTA-608-E §6.2 Table 3) live
                // at @c b1=0x10 (CC1 channel 1) with @c b2 in @c [0x20, 0x2F].
                // They set the background colour and opacity for subsequent
                // characters on the row.  Doubled per spec like other
                // control codes.  This is part of the §6.2 "extended"
                // attribute set — older 608 decoders that don't recognise
                // them treat the bytes as no-ops, so emitting them is safe.
 
                static void encodeBgAttribute(CaptionColor color, bool semiTransparent, uint8_t &b1,
                                              uint8_t &b2);
 
                static bool isBgAttribute(uint8_t b1, uint8_t b2);
 
                static bool decodeBgAttribute(uint8_t b1, uint8_t b2, CaptionColor &outColor,
                                              bool &outSemiTransparent);
 
                static bool isBt(uint8_t b1, uint8_t b2);
 
                static void encodeBackgroundTransparency(uint8_t &b1, uint8_t &b2) {
                        b1 = Cc1ExtAttrB1;
                        b2 = BtB2;
                }
 
                // -- Tab Offset codes (CTA-608-E §6.2 Table 3) -------------
                //
                // Tab Offset codes nudge the pen position 1, 2, or 3
                // columns to the right of where a PAC just landed it.
                // They're the fine-grained complement to PAC's
                // multiples-of-4 indent slots: PAC indent 8 + Tab
                // Offset T2 places a row at column 10 (8 + 2).  The
                // encoder uses them to honour @ref SubtitleAnchor's
                // horizontal half (Center / Right) when the cue's
                // computed start column isn't already a multiple of 4.
 
                static constexpr uint8_t Cc1ExtAttrB1 = 0x17;
 
                static constexpr uint8_t TabOffsetT1 = 0x21;
                static constexpr uint8_t TabOffsetT2 = 0x22;
                static constexpr uint8_t TabOffsetT3 = 0x23;
 
                static void encodeTabOffset(int columns, uint8_t &b1, uint8_t &b2);
 
                static bool isTabOffset(uint8_t b1, uint8_t b2);
 
                static bool decodeTabOffset(uint8_t b1, uint8_t b2, int &outColumns);
 
                // -- Foreground Attribute Codes (FA / FAU, BT) --------------
                //
                // CTA-608-E §6.2 Table 3: optional "extended decoder"
                // codes that supplement the standard 7-colour PAC + mid-
                // row foreground palette with a Black-foreground entry,
                // and supplement the BG attribute set with a "Background
                // Transparent" entry.  All three live in CC1's @c 0x17
                // first-byte family (CC2 form uses @c 0x1F via
                // @ref applyChannel).
                //
                // Per spec, each FA / FAU pair is preceded by a literal
                // space and "incorporates an automatic BS" on extended
                // decoders so the visual effect is a single space
                // tinted with the new colour.  The encoder honours this
                // when emitting Black-foreground spans; the decoder
                // applies the colour to subsequent characters without
                // synthesising the BS (the upstream space + BS pair
                // are a backward-compat hack for standard decoders).
                //
                // Field 2 doesn't remap these — §8.4(a)(b) only covers
                // @c 0x14 ↔ 0x15 and @c 0x1C ↔ 0x1D.  CC3 / CC4 use
                // the same 0x17 / 0x1F first bytes as CC1 / CC2.
 
                static constexpr uint8_t BtB2 = 0x2D;
                static constexpr uint8_t FaB2 = 0x2E;
                static constexpr uint8_t FauB2 = 0x2F;
 
                static void encodeFgBlack(bool underline, uint8_t &b1, uint8_t &b2) {
                        b1 = Cc1ExtAttrB1;
                        b2 = underline ? FauB2 : FaB2;
                }
 
                static bool isFgBlack(uint8_t b1, uint8_t b2) {
                        return b1 == Cc1ExtAttrB1 && (b2 == FaB2 || b2 == FauB2);
                }
 
                static bool decodeFgBlack(uint8_t b1, uint8_t b2, bool &outUnderline) {
                        if (!isFgBlack(b1, b2)) return false;
                        outUnderline = (b2 == FauB2);
                        return true;
                }
 
                // -- Null pair (no-op filler) -------------------------------
 
                static constexpr uint8_t NullB1 = 0x00;
                static constexpr uint8_t NullB2 = 0x00;
 
                // -- Doubled-control-code detection -------------------------
 
                static constexpr bool isControlPair(uint8_t b1, uint8_t b2) {
                        (void)b2;
                        return b1 >= 0x10 && b1 <= 0x1F;
                }
 
                // -- Channel retargeting (CTA-608-E §8.4) -------------------
 
                static constexpr uint8_t applyChannel(uint8_t b1, uint8_t b2, Channel channel) {
                        if (b1 < 0x10 || b1 > 0x1F) return b1;
                        uint8_t out = b1;
                        if (isSecondChannelOfField(channel)) {
                                out = static_cast<uint8_t>(out | 0x08);
                        }
                        if (isFieldTwo(channel) && b2 >= 0x20 && b2 <= 0x2F) {
                                if (out == 0x14) out = 0x15;
                                else if (out == 0x1C) out = 0x1D;
                        }
                        return out;
                }
 
                static constexpr void applyChannelInPlace(uint8_t &b1, uint8_t b2, Channel channel) {
                        b1 = applyChannel(b1, b2, channel);
                }
 
                // -- XDS framing predicates (CTA-608-E §9.3) ----------------
 
                static constexpr bool isXdsControl(uint8_t b1) {
                        return b1 >= 0x01 && b1 <= 0x0E;
                }
 
                static constexpr bool isXdsTerminator(uint8_t b1, uint8_t b2) {
                        (void)b2;
                        return b1 == 0x0F;
                }
 
                // -- Predicates ---------------------------------------------
 
                static constexpr bool isBasicChar(uint8_t c) {
                        const uint8_t v = stripParity(c);
                        return v >= 0x20 && v <= 0x7F;
                }
 
                Cea608() = delete;
};
 
struct Cea608PairDeduper {
                bool accept(uint8_t b1, uint8_t b2) {
                        if (!Cea608::isControlPair(b1, b2)) {
                                // Informational pair clears the dedup window;
                                // a control pair following an info pair is
                                // always a fresh logical event.
                                _hasPending = false;
                                return true;
                        }
                        if (_hasPending && b1 == _lastB1 && b2 == _lastB2) {
                                // Second copy of the same control pair —
                                // suppress it and clear the window so a
                                // *third* copy (rare, but seen in real
                                // streams) is recognised as a new event.
                                _hasPending = false;
                                return false;
                        }
                        _lastB1 = b1;
                        _lastB2 = b2;
                        _hasPending = true;
                        return true;
                }
 
                void reset() {
                        _lastB1 = 0;
                        _lastB2 = 0;
                        _hasPending = false;
                }
 
        private:
                uint8_t _lastB1 = 0;
                uint8_t _lastB2 = 0;
                bool    _hasPending = false;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV