ntv2caption608types.h

Go to the documentation of this file.

#ifndef __NTV2_CAPTION608TYPES_
#define __NTV2_CAPTION608TYPES_

#include "ajatypes.h"
#include "ajaexport.h"
#include "ntv2utils.h"
#include <ostream>
#include <string>
#include <set>
#include <map>

#if !defined(NULL)
    #define NULL 0
#endif



const UWord         NTV2_CC608_MinRow   (1);

const UWord         NTV2_CC608_MaxRow   (15);

const UWord         NTV2_CC608_MinCol   (1);

const UWord         NTV2_CC608_MaxCol   (32);


#define IsValidLine21Row(__row__)       ((__row__) >= NTV2_CC608_MinRow && (__row__) <= NTV2_CC608_MaxRow)
#define IsValidLine21Column(__col__)    ((__col__) >= NTV2_CC608_MinCol && (__col__) <= NTV2_CC608_MaxCol)


typedef enum NTV2Line21Field
{
    NTV2_CC608_Field_Invalid    = 0,
    NTV2_CC608_Field1           = 1,
    NTV2_CC608_Field2           = 2,
    NTV2_CC608_Field_Max        = NTV2_CC608_Field2

} NTV2Line21Field;


#define IsValidLine21Field(_field_)     ((_field_) == NTV2_CC608_Field1 || (_field_) == NTV2_CC608_Field2)
#define IsLine21Field1(_field_)         ((_field_) == NTV2_CC608_Field1)
#define IsLine21Field2(_field_)         ((_field_) == NTV2_CC608_Field2)


AJAExport const std::string &       NTV2Line21FieldToStr (const NTV2Line21Field inLine21Field);


typedef enum NTV2Line21Channel
{
    NTV2_CC608_CC1,     
    NTV2_CC608_CC2,     
    NTV2_CC608_CC3,
    NTV2_CC608_CC4,

    NTV2_CC608_TextChannelOffset,
    NTV2_CC608_Text1 = NTV2_CC608_TextChannelOffset,
    NTV2_CC608_Text2,
    NTV2_CC608_Text3,
    NTV2_CC608_Text4,

    NTV2_CC608_XDS,
    
    NTV2_CC608_ChannelMax,
    NTV2_CC608_ChannelInvalid = NTV2_CC608_ChannelMax
} NTV2Line21Channel;


#define IsValidLine21Channel(_chan_)            ((_chan_) >= NTV2_CC608_CC1 && (_chan_) < NTV2_CC608_ChannelMax)
#define IsLine21CaptionChannel(_chan_)          ((_chan_) >= NTV2_CC608_CC1 && (_chan_) <= NTV2_CC608_CC4)
#define IsLine21TextChannel(_chan_)             ((_chan_) >= NTV2_CC608_Text1 && (_chan_) <= NTV2_CC608_Text4)
#define IsLine21XDSChannel(_chan_)              ((_chan_) == NTV2_CC608_XDS)
#define IsField1Line21CaptionChannel(_chan_)    ((_chan_) == NTV2_CC608_CC1 || (_chan_) == NTV2_CC608_CC2 || (_chan_) == NTV2_CC608_Text1 || (_chan_) == NTV2_CC608_Text2)
#define IsField2Line21CaptionChannel(_chan_)    ((_chan_) == NTV2_CC608_CC3 || (_chan_) == NTV2_CC608_CC4 || (_chan_) == NTV2_CC608_Text3 || (_chan_) == NTV2_CC608_Text4)


AJAExport const std::string &   NTV2Line21ChannelToStr (const NTV2Line21Channel inLine21Channel, const bool inCompact = true);


typedef enum NTV2Line21Mode
{
    NTV2_CC608_CapModeMin,
    NTV2_CC608_CapModeUnknown = NTV2_CC608_CapModeMin,  
    NTV2_CC608_CapModePopOn,    
    NTV2_CC608_CapModeRollUp2,  
    NTV2_CC608_CapModeRollUp3,  
    NTV2_CC608_CapModeRollUp4,  
    NTV2_CC608_CapModePaintOn,  
    NTV2_CC608_CapModeMax
} NTV2Line21Mode;


#define IsValidLine21Mode(_mode_)       ((_mode_) >= NTV2_CC608_CapModePopOn && (_mode_) < NTV2_CC608_CapModeMax)
#define IsLine21PopOnMode(_mode_)       ((_mode_) == NTV2_CC608_CapModePopOn)
#define IsLine21PaintOnMode(_mode_)     ((_mode_) == NTV2_CC608_CapModePaintOn)
#define IsLine21RollUpMode(_mode_)      ((_mode_) >= NTV2_CC608_CapModeRollUp2 && (_mode_) <= NTV2_CC608_CapModeRollUp4)


AJAExport const std::string &               NTV2Line21ModeToStr (const NTV2Line21Mode inLine21Mode);


typedef enum NTV2Line21Color
{
    NTV2_CC608_White,
    NTV2_CC608_Green,
    NTV2_CC608_Blue,
    NTV2_CC608_Cyan,
    NTV2_CC608_Red,
    NTV2_CC608_Yellow,
    NTV2_CC608_Magenta,
    NTV2_CC608_Black,

    NTV2_CC608_NumColors,
    NTV2_608_INVALID_COLOR = NTV2_CC608_NumColors

} NTV2Line21Color;


#define IsValidLine21Color(_color_)     ((_color_) >= NTV2_CC608_White && (_color_) < NTV2_CC608_NumColors)
#define IsLine21WhiteColor(_color_)     ((_color_) == NTV2_CC608_White)
#define IsLine21BlackColor(_color_)     ((_color_) == NTV2_CC608_Black)


AJAExport const std::string &               NTV2Line21ColorToStr (const NTV2Line21Color inLine21Color, const bool inCompact = true);


AJAExport bool NTV2Line21ColorToYUV8 (const NTV2Line21Color inLine21Color, UByte & outY, UByte & outCb, UByte & outCr);


AJAExport bool NTV2Line21ColorToRGB8 (const NTV2Line21Color inLine21Color, UByte & outR, UByte & outG, UByte & outB, const bool inIsHD = false);


typedef enum NTV2Line21Opacity
{
    NTV2_CC608_Opaque,
    NTV2_CC608_SemiTransparent,
    NTV2_CC608_Transparent,

    NTV2_CC608_NumOpacities

} NTV2Line21Opacity;


#define IsValidLine21Opacity(_opacity_)         ((_opacity_) >= NTV2_CC608_Opaque && (_opacity_) < NTV2_CC608_NumOpacities)
#define IsLine21Transparent(_opacity_)          ((_opacity_) == NTV2_CC608_Transparent)
#define IsLine21SemiTransparent(_opacity_)      ((_opacity_) == NTV2_CC608_SemiTransparent)
#define IsLine21Opaque(_opacity_)               ((_opacity_) == NTV2_CC608_Opaque)


AJAExport const std::string &               NTV2Line21OpacityToStr (const NTV2Line21Opacity inLine21Opacity, const bool inCompact = true);


typedef enum NTV2Line21CharacterSet
{
    NTV2_CC608_DefaultCharacterSet,         //  Plain ol' normal U.S./Latin characters
    NTV2_CC608_DoubleSizeCharacterSet,
    NTV2_CC608_PrivateCharacterSet1,
    NTV2_CC608_PrivateCharacterSet2,
    NTV2_CC608_PRChinaCharacterSet,
    NTV2_CC608_KoreanCharacterSet,
    NTV2_CC608_RegisteredCharacterSet1,

    NTV2_CC608_NumCharacterSets

} NTV2Line21CharacterSet, NTV2Line21CharSet;


#define IsValidLine21CharacterSet(_charset_)    ((_charset_) >= NTV2_CC608_DefaultCharacterSet && (_charset_) < NTV2_CC608_NumCharacterSets)


AJAExport const std::string &               NTV2Line21CharacterSetToStr (const NTV2Line21CharacterSet inLine21CharSet);


typedef ULWord  NTV2_CC608_CodePoint;


typedef std::set <NTV2_CC608_CodePoint>     NTV2CodePointSet;
typedef NTV2CodePointSet::const_iterator    NTV2CodePointSetConstIter;

AJAExport std::string NTV2CodePointSetToString (const NTV2CodePointSet & inSet);    //  conflicts with classes lib ---  std::ostream & operator << (std::ostream & inOutStream, const NTV2CodePointSet & inSet);


inline NTV2_CC608_CodePoint     Make608CodePoint (const UByte in608Byte1, const UByte in608Byte2, const NTV2Line21CharacterSet inCharSet = NTV2_CC608_DefaultCharacterSet)
{
    return NTV2_CC608_CodePoint (ULWord (inCharSet << 24) | ULWord (in608Byte1 << 8) | ULWord (in608Byte2));
}

AJAExport std::string       NTV2CC608CodePointToUtf8String (const NTV2_CC608_CodePoint in608CodePoint);

AJAExport UWord             NTV2CC608CodePointToUtf16Char (const NTV2_CC608_CodePoint in608CodePoint);


inline NTV2Line21CharacterSet   GetLine21CharacterSet (const NTV2_CC608_CodePoint inCodePoint)
{
    return NTV2Line21CharacterSet ((inCodePoint & 0xFF000000) >> 24);
}


inline UByte    Get608Byte1 (const NTV2_CC608_CodePoint inCodePoint)
{
    return UByte ((inCodePoint & 0x00FF00) >> 8);
}


inline UByte    Get608Byte2 (const NTV2_CC608_CodePoint inCodePoint)
{
    return UByte (inCodePoint & 0x000000FF);
}


typedef struct AJAExport NTV2Line21Attributes
{
    public:
        explicit                        NTV2Line21Attributes ();

        explicit                        NTV2Line21Attributes (  const NTV2Line21Color   inFGColor,
                                                                const NTV2Line21Color   inBGColor   = NTV2_CC608_Black,
                                                                const NTV2Line21Opacity inOpacity   = NTV2_CC608_Opaque,
                                                                const bool              inItalics   = false,
                                                                const bool              inUnderline = false,
                                                                const bool              inFlash     = false);
        inline                          NTV2Line21Attributes (  const NTV2Line21Attributes & inRHS) {   bFlash      = inRHS.bFlash;
                                                                                                        bItalic     = inRHS.bItalic;
                                                                                                        bUnderline  = inRHS.bUnderline;
                                                                                                        fgColor     = inRHS.fgColor;
                                                                                                        bgColor     = inRHS.bgColor;
                                                                                                        bgOpacity   = inRHS.bgOpacity;  }
        inline  NTV2Line21Attributes &  operator = (const NTV2Line21Attributes & inRHS)             {   bFlash      = inRHS.bFlash;
                                                                                                        bItalic     = inRHS.bItalic;
                                                                                                        bUnderline  = inRHS.bUnderline;
                                                                                                        fgColor     = inRHS.fgColor;
                                                                                                        bgColor     = inRHS.bgColor;
                                                                                                        bgOpacity   = inRHS.bgOpacity;  return *this;}

        inline bool                     IsSet (void) const                              { return bFlash || bItalic || bUnderline
                                                                                                || fgColor != NTV2_CC608_White
                                                                                                || bgColor != NTV2_CC608_Black
                                                                                                || bgOpacity != NTV2_CC608_Opaque; }

        inline NTV2Line21Color          GetColor (void) const                           { return NTV2Line21Color(fgColor); }

        inline NTV2Line21Color          GetBGColor (void) const                         { return NTV2Line21Color(bgColor); }

        inline NTV2Line21Opacity        GetOpacity (void) const                         { return NTV2Line21Opacity(bgOpacity); }

        inline bool                     IsItalicized (void) const                       { return bItalic; }

        inline bool                     IsUnderlined (void) const                       { return bUnderline; }

        inline bool                     IsFlashing (void) const                         { return bFlash; }

        inline NTV2Line21Attributes &   AddItalics (void)                               { bItalic = true;           return *this; }

        inline NTV2Line21Attributes &   RemoveItalics (void)                            { bItalic = false;          return *this; }

        inline NTV2Line21Attributes &   SetItalics (const bool inItalics)               { bItalic = inItalics;      return *this; }


        inline NTV2Line21Attributes &   AddUnderline (void)                             { bUnderline = true;        return *this; }

        inline NTV2Line21Attributes &   RemoveUnderline (void)                          { bUnderline = false;       return *this; }

        inline NTV2Line21Attributes &   SetUnderline (const bool inUnderline)           { bUnderline = inUnderline; return *this; }


        inline NTV2Line21Attributes &   AddFlash (void)                                 { bFlash = true;            return *this; }

        inline NTV2Line21Attributes &   RemoveFlash (void)                              { bFlash = false;           return *this; }

        inline NTV2Line21Attributes &   SetFlash (const bool inFlash)                   { bFlash = inFlash;         return *this; }


        inline NTV2Line21Attributes &   SetColor (const NTV2Line21Color inFGColor)      { fgColor = inFGColor;      return *this; }

        inline NTV2Line21Attributes &   SetBGColor (const NTV2Line21Color inBGColor)    { bgColor = inBGColor;      return *this; }

        inline NTV2Line21Attributes &   SetOpacity (const NTV2Line21Opacity inOpacity)  { bgOpacity = inOpacity;    return *this; }


        inline void                     Clear (void)                                    { bFlash = bItalic = bUnderline = false;
                                                                                            fgColor = NTV2_CC608_White;
                                                                                            bgColor = NTV2_CC608_Black;
                                                                                            bgOpacity = NTV2_CC608_Opaque; }

        inline bool                     operator < (const NTV2Line21Attributes & inRHS) const                       { return GetHashKey () < inRHS.GetHashKey (); }

        inline bool                     operator == (const NTV2Line21Attributes & inRHS) const                      { return GetHashKey () == inRHS.GetHashKey (); }

        inline bool                     operator != (const NTV2Line21Attributes & inRHS) const                      { return !(*this == inRHS);}

        std::string                     GetHexString (void) const;

        uint16_t                        GetHashKey (void) const;


    //  Instance Data
    private:
        bool     bFlash     :1;     
        bool     bItalic    :1;     
        bool     bUnderline :1;     
        unsigned fgColor    :3;     
        unsigned bgColor    :3;     
        unsigned bgOpacity  :2;     

} NTV2Line21Attributes, NTV2Line21Attrs;

typedef NTV2Line21Attrs *   NTV2Line21AttrsPtr;
typedef NTV2Line21AttrsPtr  NTV2Line21AttributesPtr;


AJAExport std::ostream & operator << (std::ostream & inOutStream, const NTV2Line21Attrs & inData);



//  CONVERSION TO/FROM STRINGS


AJAExport std::string                   NTV2Line21AttributesToStr (const NTV2Line21Attributes inLine21Attributes);


AJAExport NTV2Line21Field               StrToNTV2Line21Field (const std::string & inStr);


AJAExport NTV2Line21Channel             StrToNTV2Line21Channel (const std::string & inStr);


AJAExport NTV2Line21Mode                StrToNTV2Line21Mode (const std::string & inStr);


AJAExport NTV2Line21Color               StrToNTV2Line21Color (const std::string & inStr);


AJAExport NTV2Line21Opacity             StrToNTV2Line21Opacity (const std::string & inStr);


AJAExport NTV2Line21CharacterSet        StrToNTV2Line21CharacterSet (const std::string & inStr);


AJAExport NTV2Line21Attributes          StrToNTV2Line21Attributes (const std::string & inStr);



typedef struct AJAExport CaptionData
{
    bool    bGotField1Data; 
    UByte   f1_char1;       
    UByte   f1_char2;       
    
    bool    bGotField2Data; 
    UByte   f2_char1;       
    UByte   f2_char2;       
    
    bool    bGotField3Data; 
    UByte   f3_char1;       
    UByte   f3_char2;       

    public:
        explicit inline     CaptionData ()  { bGotField1Data = bGotField2Data = bGotField3Data = false;  f1_char1 = f1_char2 = f2_char1 = f2_char2 = f3_char1 = f3_char2 = 0xFF; }

        explicit            CaptionData (const UByte inF1Char1, const UByte inF1Char2);

        explicit            CaptionData (const UByte inF1Char1, const UByte inF1Char2, const UByte inF2Char1, const UByte inF2Char2);

        inline bool         HasF1Data (void) const  {return (bGotField1Data && (f1_char1 != 0x80 || f1_char2 != 0x80));}

        inline bool         HasF2Data (void) const  {return (bGotField2Data && (f2_char1 != 0x80 || f2_char2 != 0x80));}

        inline bool         HasData (void) const                {return HasF1Data() || HasF2Data();}

        inline bool         IsF1Invalid (void) const            {return f1_char1 == 0xFF && f1_char2 == 0xFF;}

        inline bool         IsF2Invalid (void) const            {return f2_char1 == 0xFF && f2_char2 == 0xFF;}

        inline bool         IsError (void) const                {return IsF1Invalid() && IsF2Invalid();}

        inline CaptionData &    SetF1Data (const CaptionData & inRHS)   {f1_char1 = inRHS.f1_char1; f1_char2 = inRHS.f1_char2; bGotField1Data = inRHS.bGotField1Data; return *this;}

        inline CaptionData &    SetF1Data (const UByte inF1Char1, const UByte inF1Char2)    {f1_char1 = inF1Char1; f1_char2 = inF1Char2; bGotField1Data = inF1Char1 != 0xFF && inF1Char2 != 0xFF; return *this;}

        inline CaptionData &    SetF2Data (const CaptionData & inRHS)   {f2_char1 = inRHS.f2_char1; f2_char2 = inRHS.f2_char2; bGotField2Data = inRHS.bGotField2Data; return *this;}

        inline CaptionData &    SetF2Data (const UByte inF2Char1, const UByte inF2Char2)    {f2_char1 = inF2Char1; f2_char2 = inF2Char2; bGotField2Data = inF2Char1 != 0xFF && inF2Char2 != 0xFF; return *this;}

        inline void         Clear (void)    {bGotField1Data = bGotField2Data = bGotField3Data = false;  f1_char1 = f1_char2 = f2_char1 = f2_char2 = f3_char1 = f3_char2 = 0x80;}

        inline void         Zero (void)     {bGotField1Data = bGotField2Data = bGotField3Data = false;  f1_char1 = f1_char2 = f2_char1 = f2_char2 = f3_char1 = f3_char2 = 0x00;}

        bool                operator == (const CaptionData & inRHS) const;
        bool                operator < (const CaptionData & inRHS) const;
        inline bool         operator != (const CaptionData & inRHS) const   {return !(*this == inRHS);}
} CaptionData;


AJAExport std::ostream & operator << (std::ostream & inOutStream, const CaptionData & inData);


class AJAExport NTV2Caption608ChangeInfo
{
    public:
        typedef enum NTV2Caption608Change
        {
            NTV2DecoderChange_None              = 0,        
            NTV2DecoderChange_CurrentChannel    = 1,        
            NTV2DecoderChange_CurrentRow        = 2,        
            NTV2DecoderChange_CurrentColumn     = 4,        
            NTV2DecoderChange_CurrentScreen     = 8,        
            NTV2DecoderChange_CaptionMode       = 16,       
            NTV2DecoderChange_ScreenCharacter   = 32,       
            NTV2DecoderChange_ScreenAttribute   = 64,       
            NTV2DecoderChange_DrawScreen        = 128,      
            NTV2DecoderChange_All               = 0xFFFF    
        } NTV2Caption608Change;

    public:
        explicit    NTV2Caption608ChangeInfo (const NTV2Line21Channel inChannel);
        explicit    NTV2Caption608ChangeInfo (const NTV2Line21Channel inOldChannel, const NTV2Line21Channel inNewChannel);
        explicit    NTV2Caption608ChangeInfo (const NTV2Line21Channel inChannel, const UWord inWhatChanged, const UWord inOldValue, const UWord inNewValue);
        explicit    NTV2Caption608ChangeInfo (const NTV2Line21Channel inChannel, const UWord inScreen, const UWord inRow, const UWord inColumn, const NTV2_CC608_CodePoint inOldValue, const NTV2_CC608_CodePoint inNewValue);
        explicit    NTV2Caption608ChangeInfo (const NTV2Line21Channel inChannel, const UWord inScreen, const UWord inRow, const UWord inColumn, const NTV2Line21Attributes & inOldValue, const NTV2Line21Attributes & inNewValue);
        std::ostream &  Print (std::ostream & inOutStrm) const;

    public:
        union _u
        {
            struct _currentChannel
            {
                UWord                   mOld;       
            }   currentChannel;
            struct _currentRow
            {
                UWord                   mOld;       
                UWord                   mNew;       
            }   currentRow;
            struct _currentColumn
            {
                UWord                   mOld;       
                UWord                   mNew;       
            }   currentColumn;
            struct _currentScreen
            {
                UWord                   mOld;       
                UWord                   mNew;       
            }   currentScreen;
            struct _captionMode
            {
                UWord                   mOld;       
                UWord                   mNew;       
            }   captionMode;
            struct _screenChar
            {
                UWord                   mScreenNum; 
                UWord                   mRow;       
                UWord                   mColumn;    
                NTV2_CC608_CodePoint    mOld;       
                NTV2_CC608_CodePoint    mNew;       
            }   screenChar;
            struct _screenAttr
            {
                UWord                   mScreenNum; 
                UWord                   mRow;       
                UWord                   mColumn;    
                uint16_t                mOld;       
                uint16_t                mNew;       
            }   screenAttr;
        }   u;

        UWord                   mWhatChanged;       
        NTV2Line21Channel       mChannel;           

};  //  NTV2Caption608ChangeInfo


inline std::ostream & operator << (std::ostream & oss, const NTV2Caption608ChangeInfo & inInfo) {return inInfo.Print(oss);}


typedef void (NTV2Caption608Changed) (void * pInstance, const NTV2Caption608ChangeInfo & inChangeInfo);


class AJAExport NTV2Line21AttributePermutations
{
    public:
        NTV2Line21AttributePermutations ();

        const NTV2Line21Attrs &     GetPermutation (const size_t inIndex) const;

        inline ULWord               size (void) const                           {return 3 * 2 * 8 * 2 * 8;}

        size_t                      GetIndexFromAttribute (const NTV2Line21Attributes & inAttribute) const;

        inline const NTV2Line21Attrs &  operator [] (const size_t inIndex) const    {return GetPermutation(inIndex);}

    private:
        NTV2Line21Attrs mAttribs [3 * 2 * 8 * 2 * 8];   //  3 opacities  x  w/wo underline  x  8 BG colors  x  w/wo italics  x  8 FG colors

};  //  NTV2Line21AttributePermutations

#endif  // __NTV2_CAPTION608TYPES_