ancillarydata.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef AJA_ANCILLARYDATA_H
#define AJA_ANCILLARYDATA_H

#include "ajatypes.h"
#include "ntv2version.h"
#include "ajabase/common/types.h"   //  for AJAStatus
#include "ntv2publicinterface.h"
#include <sstream>
#include <vector>


// Default Packet IDs used when building "analog" packets
// NOTE:    There's NO guarantee that the Anc Extractor hardware will use these codes - nor does the
//          Anc Inserter hardware care. To determine if a given packet is "analog" or "digital", check
//          the appropriate flag in the packet header. This is just to have all the locally (software)
//          built "analog" IDs come from a single location.
const uint8_t AJAAncData_AnalogDID = 0x00;
const uint8_t AJAAncData_AnalogSID = 0x00;

typedef std::pair <uint8_t, uint8_t>        AJAAncDIDSIDPair, AJAAncillaryDIDSIDPair;   
typedef uint16_t                            AJAAncPktDIDSID;    
#define ToAJAAncPktDIDSID(_d_,_s_)          (uint16_t((_d_) << 8) | uint16_t(_s_))
#define FromAJAAncPktDIDSID(_k_,_d_,_s_)    (_d_) = uint8_t(((_k_) & 0xFF00) >> 8); (_d_) = uint8_t(_k_ & 0x00FF);

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


typedef enum
{
    AJAAncDataType_Unknown,             
    AJAAncDataType_Smpte2016_3,         
    AJAAncDataType_Timecode_ATC,        
    AJAAncDataType_Timecode_VITC,       
    AJAAncDataType_Cea708,              
    AJAAncDataType_Cea608_Vanc,         
    AJAAncDataType_Cea608_Line21,       
    AJAAncDataType_Smpte352,            
    AJAAncDataType_Smpte2051,           
    AJAAncDataType_FrameStatusInfo524D, 
    AJAAncDataType_FrameStatusInfo5251, 
    AJAAncDataType_HDR_SDR,
    AJAAncDataType_HDR_HDR10,
    AJAAncDataType_HDR_HLG,
    AJAAncDataType_HDMI_Aux,            
    AJAAncDataType_Size
} AJAAncDataType;

#define IS_VALID_AJAAncDataType(_x_)        ((_x_) >= AJAAncDataType_Unknown  &&  (_x_) < AJAAncDataType_Size)
#define IS_KNOWN_AJAAncDataType(_x_)        ((_x_) > AJAAncDataType_Unknown  &&  (_x_) < AJAAncDataType_Size)

AJAExport const std::string & AJAAncDataTypeToString (const AJAAncDataType inValue, const bool inCompact = true);



typedef enum
{
    AJAAncDataLink_A,           
    AJAAncDataLink_B,           
    AJAAncDataLink_LeftEye  = AJAAncDataLink_A, 
    AJAAncDataLink_RightEye = AJAAncDataLink_B, 
    AJAAncDataLink_Unknown, 
    AJAAncDataLink_Size
} AJAAncDataLink;

#define IS_VALID_AJAAncDataLink(_x_)        ((_x_) >= AJAAncDataLink_A  &&  (_x_) < AJAAncDataLink_Unknown)

AJAExport const std::string &   AJAAncDataLinkToString (const AJAAncDataLink inValue, const bool inCompact = true);



typedef enum
{
    AJAAncDataStream_1,     
    AJAAncDataStream_2,     
    AJAAncDataStream_3,     
    AJAAncDataStream_4,     
    AJAAncDataStream_Unknown,   
    AJAAncDataStream_Size
} AJAAncDataStream, AJAAncillaryDataStream;

#define IS_VALID_AJAAncDataStream(_x_)  ((_x_) >= AJAAncDataStream_1  &&  (_x_) < AJAAncDataStream_Unknown)
#define IS_LINKA_AJAAncDataStream(_x_)  ((_x_) == AJAAncDataStream_1)
#define IS_LINKB_AJAAncDataStream(_x_)  ((_x_) == AJAAncDataStream_2)

AJAExport const std::string &   AJAAncDataStreamToString (const AJAAncDataStream inValue, const bool inCompact = true);



typedef enum
{
    AJAAncDataChannel_C,            
    AJAAncDataChannel_Both = AJAAncDataChannel_C,   
    AJAAncDataChannel_Y,            
    AJAAncDataChannel_Unknown,      
    AJAAncDataChannel_Size
} AJAAncDataChannel;

#define IS_VALID_AJAAncDataChannel(_x_)         ((_x_) >= AJAAncDataChannel_C  &&  (_x_) < AJAAncDataChannel_Unknown)

AJAExport const std::string &   AJAAncDataChannelToString (const AJAAncDataChannel inValue, const bool inCompact = true);



typedef enum
{
    AncChannelSearch_Y,         
    AncChannelSearch_C,         
    AncChannelSearch_Both,      
    AncChannelSearch_Invalid    
} AncChannelSearchSelect;

#define IS_VALID_AncChannelSearchSelect(_x_)    ((_x_) >= AncChannelSearch_Y  &&  (_x_) < AncChannelSearch_Invalid)

AJAExport std::string AncChannelSearchSelectToString (const AncChannelSearchSelect inSelect, const bool inCompact = true);


typedef enum
{
    AJAAncDataSpace_VANC,       
    AJAAncDataSpace_HANC,       
    AJAAncDataSpace_Unknown,    
    AJAAncDataSpace_Size
} AJAAncDataSpace;

#define IS_VALID_AJAAncDataSpace(_x_)       ((_x_) >= AJAAncDataSpace_VANC  &&  (_x_) < AJAAncDataSpace_Unknown)
#define IS_HANC_AJAAncDataSpace(_x_)        ((_x_) == AJAAncDataSpace_HANC)
#define IS_VANC_AJAAncDataSpace(_x_)        ((_x_) == AJAAncDataSpace_VANC)

AJAExport const std::string &   AJAAncDataSpaceToString (const AJAAncDataSpace inValue, const bool inCompact = true);



#define AJAAncDataLineNumber_Unknown    uint16_t(0x0000)    
#define AJAAncDataLineNumber_DontCare   uint16_t(0x07FF)    
#define AJAAncDataLineNumber_Anywhere   (AJAAncDataLineNumber_DontCare)
#define AJAAncDataLineNumber_AnyVanc    uint16_t(0x07FE)    
#define AJAAncDataLineNumber_Future     uint16_t(0x07FD)    

#define IS_UNKNOWN_AJAAncDataLineNumber(_x_)        ((_x_) == AJAAncDataLineNumber_Unknown)
#define IS_IRRELEVANT_AJAAncDataLineNumber(_x_)     ((_x_) == AJAAncDataLineNumber_DontCare)
#define IS_GOOD_AJAAncDataLineNumber(_x_)           ((_x_) > 0  &&  (_x_) < AJAAncDataLineNumber_DontCare)

AJAExport std::string AJAAncLineNumberToString (const uint16_t inValue);

//  Special horizOffset values:
#define AJAAncDataHorizOffset_Unknown   uint16_t(0x0000)    
#define AJAAncDataHorizOffset_Anywhere  uint16_t(0x0FFF)    
#define AJAAncDataHorizOffset_AnyHanc   uint16_t(0x0FFE)    
#define AJAAncDataHorizOffset_AnyVanc   uint16_t(0x0FFD)    
#define AJAAncDataHorizOffset_Future    uint16_t(0x0FFC)    


AJAExport std::string AJAAncHorizOffsetToString (const uint16_t inValue);


typedef struct AJAExport AJAAncDataLoc
{
    //  Instance Methods
    public:
        inline  AJAAncDataLoc ( const AJAAncDataLink    inLink          = AJAAncDataLink_Unknown,
                                const AJAAncDataChannel inChannel       = AJAAncDataChannel_Unknown,
                                const AJAAncDataSpace   inIgnored       = AJAAncDataSpace_Unknown,
                                const uint16_t          inLineNum       = AJAAncDataLineNumber_Unknown,
                                const uint16_t          inHorizOffset   = AJAAncDataHorizOffset_Unknown,
                                const AJAAncDataStream  inStream        = AJAAncDataStream_1)
        {   AJA_UNUSED(inIgnored);
            SetDataLink(inLink).SetDataChannel(inChannel).SetLineNumber(inLineNum).SetHorizontalOffset(inHorizOffset).SetDataStream(inStream);
        }

        inline bool     operator == (const AJAAncDataLoc & inRHS) const
        {
            //  Everything must match exactly:
            bool equal = (GetDataLink() == inRHS.GetDataLink()
                        &&  GetDataStream() == inRHS.GetDataStream()
                            &&  GetDataChannel() == inRHS.GetDataChannel()
//  No longer necessary         &&  GetDataSpace() == inRHS.GetDataSpace()
                                    &&  GetLineNumber() == inRHS.GetLineNumber());
            if (equal  &&  GetHorizontalOffset()  &&  inRHS.GetHorizontalOffset())
                equal = (GetHorizontalOffset() == inRHS.GetHorizontalOffset());

            return equal;
        }

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

        inline bool     operator < (const AJAAncDataLoc & inRHS) const
        {
            const uint64_t  lhs (OrdinalValue());
            const uint64_t  rhs (inRHS.OrdinalValue());
            return lhs < rhs;   //  64-bit unsigned compare:
        }

        inline bool     IsValid (void) const
        {
            return IS_VALID_AJAAncDataLink(mLink)
                    && IS_VALID_AJAAncDataStream(mStream)
                        && IS_VALID_AJAAncDataChannel(mChannel)
                            && (IS_VALID_AJAAncDataSpace(GetDataSpace())
                                    || (GetDataSpace() == AJAAncDataSpace_Unknown));
        }

        virtual AJAStatus   Compare (const AJAAncDataLoc & inRHS) const;

        virtual std::string CompareWithInfo (const AJAAncDataLoc & inRHS) const;

        inline AJAAncDataLoc &  Reset (void)
        {
            mLink           = AJAAncDataLink_Unknown;
            mStream         = AJAAncDataStream_Unknown;
            mChannel        = AJAAncDataChannel_Unknown;
            mLineNum        = AJAAncDataLineNumber_Unknown;
            mHorizOffset    = AJAAncDataHorizOffset_Unknown;
            return *this;
        }

        inline AJAAncDataLink           GetDataLink (void) const                {return mLink;}     
        inline bool                     IsDataLinkA (void) const                {return mLink == AJAAncDataLink_A;}
        inline bool                     IsDataLinkB (void) const                {return mLink == AJAAncDataLink_B;}

        inline AJAAncDataStream         GetDataStream (void) const              {return mStream;}       

        inline AJAAncDataChannel        GetDataChannel (void) const             {return mChannel;}      
        inline bool                     IsLumaChannel (void) const              {return mChannel == AJAAncDataChannel_Y;}
        inline bool                     IsChromaChannel (void) const            {return mChannel == AJAAncDataChannel_C;}

        inline AJAAncDataSpace  GetDataSpace (void) const
        {
            if (mHorizOffset == AJAAncDataHorizOffset_AnyVanc)
                return AJAAncDataSpace_VANC;
            if (mHorizOffset == AJAAncDataHorizOffset_AnyHanc)
                return AJAAncDataSpace_HANC;
            return AJAAncDataSpace_Unknown;
        }
        inline bool             IsVanc (void) const                     {return GetDataSpace() == AJAAncDataSpace_VANC;}
        inline bool             IsHanc (void) const                     {return GetDataSpace() == AJAAncDataSpace_HANC;}

        inline uint16_t         GetLineNumber (void) const              {return mLineNum;}      

        inline uint16_t         GetHorizontalOffset (void) const        {return mHorizOffset & 0x0FFF;}

        std::ostream &          Print (std::ostream & ostrm, const bool inCompact = true) const;

        inline AJAAncDataLoc &  SetDataLink (const AJAAncDataLink inLink)                       {mLink = inLink;    return *this;}

        inline AJAAncDataLoc &  SetDataStream (const AJAAncDataStream inStream)                 {mStream = inStream;    return *this;}

        inline AJAAncDataLoc &  SetDataChannel (const AJAAncDataChannel inChannel)              {mChannel = inChannel; return *this;}
#if AJA_NTV2_SDK_VERSION_AT_LEAST(16,3)
        inline AJAAncDataLoc &  SetDataVideoStream (const AJAAncDataChannel inChannel)          {return SetDataChannel(inChannel);}
#endif

        inline AJAAncDataLoc &  SetDataSpace (const AJAAncDataSpace inSpace)
        {
            if (IS_VANC_AJAAncDataSpace(inSpace))
                mHorizOffset = AJAAncDataHorizOffset_AnyVanc;
            else if (IS_HANC_AJAAncDataSpace(inSpace))
                mHorizOffset = AJAAncDataHorizOffset_AnyHanc;
            return *this;
        }

        inline AJAAncDataLoc &  SetLineNumber (const uint16_t inLineNum)                            {mLineNum = inLineNum; return *this;}


        inline AJAAncDataLoc &  SetHorizontalOffset (uint16_t inHOffset)
        {   inHOffset &= 0x0FFF;
            if (inHOffset == AJAAncDataHorizOffset_AnyVanc)
                mHorizOffset = inHOffset;   //  Force [any] VANC
            else if (inHOffset == AJAAncDataHorizOffset_AnyHanc)
                mHorizOffset = inHOffset;   //  Force [any] HANC
            else if (inHOffset == AJAAncDataHorizOffset_Anywhere)
                mHorizOffset = inHOffset;   //  Anywhere (unknown DataSpace)
            else
                mHorizOffset = inHOffset;   //  Trust the caller;  don't mess with existing DataSpace
            return *this;
        }

        inline uint64_t         OrdinalValue (void) const
        {   //  64-bit unsigned compare:                    LLLLLLLLLLLLSSSHHHHHHHHHHHHCCCDDDDDDDKK
            const uint64_t  hOffset (mHorizOffset == AJAAncDataHorizOffset_AnyVanc || mHorizOffset == AJAAncDataHorizOffset_Anywhere ? 0 : mHorizOffset);
            return ((uint64_t(mLineNum) << 27)          //  LLLLLLLLLLLL
                    | (uint64_t(GetDataSpace()) << 24)  //              SSS
                    | (hOffset << 12)                   //                 HHHHHHHHHHHH
                    | (uint64_t(mChannel) << 9)         //                             CCC
                    | (uint64_t(mStream) << 2)          //                                DDDDDDD
                    | uint64_t(mLink));                 //                                       KK
        }

    private:    //  Made private in SDK 15.2
        AJAAncDataLink      mLink;          
        AJAAncDataStream    mStream;        
        AJAAncDataChannel   mChannel;       
        uint16_t            mLineNum;       
        uint16_t            mHorizOffset;   

} AJAAncDataLoc;

typedef AJAAncDataLoc   AJAAncillaryDataLocation;
typedef AJAAncDataLoc * AJAAncDataLocPtr;

AJAExport std::string   AJAAncDataLocToString (const AJAAncDataLoc & inValue, const bool inCompact = true);

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



typedef enum
{
    AJAAncDataCoding_Digital,       
    AJAAncDataCoding_Raw,           
    AJAAncDataCoding_Unknown,       
    AJAAncDataCoding_Size
} AJAAncDataCoding;

#define IS_VALID_AJAAncDataCoding(_x_)          ((_x_) >= AJAAncDataCoding_Digital  &&  (_x_) < AJAAncDataCoding_Size)

AJAExport const std::string &   AJAAncDataCodingToString (const AJAAncDataCoding inValue, const bool inCompact = true);



typedef enum
{
    AJAAncBufferFormat_Unknown,     
    AJAAncBufferFormat_FBVANC,      
    AJAAncBufferFormat_SDI,         
    AJAAncBufferFormat_RTP,         
    AJAAncBufferFormat_HDMI,        
    AJAAncBufferFormat_Invalid,     
    AJAAncBufferFormat_Size = AJAAncBufferFormat_Invalid

} AJAAncBufferFormat;

#define IS_VALID_AJAAncBufferFormat(_x_)        ((_x_) >= AJAAncBufferFormat_Unknown  &&  (_x_) < AJAAncBufferFormat_Size)
#define IS_KNOWN_AJAAncBufferFormat(_x_)        ((_x_) > AJAAncBufferFormat_Unknown  &&  (_x_) < AJAAncBufferFormat_Size)

AJAExport const std::string &   AJAAncBufferFormatToString (const AJAAncBufferFormat inValue, const bool inCompact = true);


class AJAExport AJAAncillaryData
{
public:

    AJAAncillaryData ();    

    AJAAncillaryData (const AJAAncillaryData & inClone);

    AJAAncillaryData (const AJAAncillaryData * pInClone);

    virtual                                 ~AJAAncillaryData ();   
    virtual void                            Clear (void);           
    virtual AJAAncillaryData *              Clone (void) const;     



    virtual inline uint8_t                  GetDID (void) const                         {return m_DID;}                         
    virtual inline uint8_t                  GetSID (void) const                         {return m_SID;}                         
    virtual inline uint32_t                 GetDC (void) const                          {return uint32_t(m_payload.size());}    
    virtual inline AJAAncDIDSIDPair         GetDIDSIDPair (void) const                  {return AJAAncDIDSIDPair(GetDID(),GetSID());}   
    virtual inline AJAAncPktDIDSID          GetDIDSID (void) const                      {return ToAJAAncPktDIDSID(GetDID(),GetSID());}  
    virtual inline size_t                   GetPayloadByteCount (void) const            {return size_t(GetDC());}               
    virtual AJAAncDataType                  GetAncillaryDataType (void) const           {return m_ancType;}                     
    virtual inline uint32_t                 GetFrameID (void) const                     {return m_frameID;}                     

    virtual inline const AJAAncDataLoc &    GetDataLocation (void) const                {return m_location;}                    
    virtual inline AJAAncDataLoc &          GetDataLocation (void)                      {return m_location;}                    
    virtual inline AJAAncDataCoding         GetDataCoding (void) const                  {return m_coding;}                      
    virtual inline AJAAncBufferFormat       GetBufferFormat (void) const                {return m_bufferFmt;}                   
    virtual uint8_t                         GetChecksum (void) const                    {return m_checksum;}                    

    virtual inline AJAAncDataLink           GetLocationVideoLink (void) const           {return GetDataLocation().GetDataLink();}               
    virtual inline AJAAncDataStream         GetLocationDataStream (void) const          {return GetDataLocation().GetDataStream();}             
    virtual inline AJAAncDataChannel        GetLocationDataChannel (void) const         {return GetDataLocation().GetDataChannel();}            
    virtual inline AJAAncDataSpace          GetLocationVideoSpace (void) const          {return GetDataLocation().GetDataSpace();}              
    virtual inline uint16_t                 GetLocationLineNumber (void) const          {return GetDataLocation().GetLineNumber();}             
    virtual inline uint16_t                 GetLocationHorizOffset (void) const         {return GetDataLocation().GetHorizontalOffset();}       
    virtual uint16_t                        GetStreamInfo (void) const;                                                                         
    virtual inline const uint64_t &         UserData (void) const                       {return m_userData;}                    

    virtual uint8_t                         GetAuxType (void) const                     {return m_auxType;}                     
    virtual uint8_t                         GetAuxHB1 (void) const                      {return m_auxHB1;}                      
    virtual uint8_t                         GetAuxHB2 (void) const                      {return m_auxHB2;}                      

    virtual inline bool                     HasStreamInfo (void) const                  {return IS_VALID_AJAAncDataLink(GetLocationVideoLink()) && IS_VALID_AJAAncDataStream(GetLocationDataStream());}
    virtual inline bool                     IsEmpty (void) const                        {return GetDC() == 0;}                                  
    virtual inline bool                     IsLumaChannel (void) const                  {return GetDataLocation().IsLumaChannel ();}            
    virtual inline bool                     IsChromaChannel (void) const                {return GetDataLocation().IsChromaChannel ();}          
    virtual inline bool                     IsVanc (void) const                         {return GetDataLocation().IsVanc ();}                   
    virtual inline bool                     IsHanc (void) const                         {return GetDataLocation().IsHanc ();}                   
    virtual inline bool                     IsDigital (void) const                      {return GetDataCoding() == AJAAncDataCoding_Digital;}   
    virtual inline bool                     IsRaw (void) const                          {return GetDataCoding() == AJAAncDataCoding_Raw;}       
    virtual inline bool                     IsFBVANC (void) const                       {return GetBufferFormat() == AJAAncBufferFormat_FBVANC;}    
    virtual inline bool                     IsSDI (void) const                          {return GetBufferFormat() == AJAAncBufferFormat_SDI;}       
    virtual inline bool                     IsRTP (void) const                          {return GetBufferFormat() == AJAAncBufferFormat_RTP;}       
    virtual inline bool                     IsHDMI (void) const                         {return GetBufferFormat() == AJAAncBufferFormat_HDMI;}      
                                
    virtual bool                            isHDMIAuxInfoFrame(void) const              {return false;}

    virtual uint8_t                         Calculate8BitChecksum (void) const;

    virtual uint16_t                        Calculate9BitChecksum (void) const;

    virtual bool                            ChecksumOK (void) const                     {return m_checksum == Calculate8BitChecksum ();}

    AJAAncillaryData &                      operator = (const AJAAncillaryData & inRHS);

    virtual bool                            operator == (const AJAAncillaryData & inRHS) const;

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

    virtual AJAStatus                       Compare (const AJAAncillaryData & inRHS, const bool inIgnoreLocation = true, const bool inIgnoreChecksum = true) const;



    virtual AJAStatus                       SetDID (const uint8_t inDataID);

    virtual AJAStatus                       SetSID (const uint8_t inSID);

    virtual inline AJAStatus                SetDIDSID (const AJAAncDIDSIDPair & inDIDSID)       {SetDID(inDIDSID.first); return SetSID(inDIDSID.second);}   //  New in SDK 16.0

    virtual AJAStatus                       SetChecksum (const uint8_t inChecksum8, const bool inValidate = false);

    virtual AJAStatus                       SetDataLocation (const AJAAncDataLoc & inLoc);

    virtual AJAStatus                       SetLocationVideoLink (const AJAAncDataLink inLink);

    virtual AJAStatus                       SetLocationDataStream (const AJAAncDataStream inStream);

    virtual AJAStatus                       SetLocationDataChannel (const AJAAncDataChannel inChannel);

    virtual AJAStatus                       SetLocationLineNumber (const uint16_t inLineNum);

    virtual AJAStatus                       SetLocationHorizOffset (const uint16_t inOffset);

    virtual AJAStatus                       SetDataCoding (const AJAAncDataCoding inCodingType);

    virtual inline AJAAncillaryData &       SetFrameID (const uint32_t inFrameID)                   {m_frameID = inFrameID;  return *this;}

    virtual inline AJAAncillaryData &       SetBufferFormat (const AJAAncBufferFormat inFmt)        {m_bufferFmt = inFmt;  return *this;}

    virtual inline uint64_t &               UserData (void)         {return m_userData;}    



    virtual uint8_t                         GetPayloadByteAtIndex (const uint32_t inIndex0) const;

    virtual inline const uint8_t *          GetPayloadData (void) const                 {return m_payload.empty() ? NULL : &(m_payload[0]);}

    virtual AJAStatus                       GetPayloadData (uint8_t * pBuffer, const uint32_t inByteCapacity) const;

    virtual AJAStatus                       GetPayloadData (UWordSequence & outUDWs, const bool inAddParity = true) const;



    virtual AJAStatus                       SetPayloadByteAtIndex (const uint8_t inDataByte, const uint32_t inIndex0);

    virtual AJAStatus                       SetPayloadData (const uint8_t * pInData, const uint32_t inByteCount);

    virtual AJAStatus                       AppendPayloadData (const uint8_t * pInBuffer, const uint32_t inByteCount);

    virtual AJAStatus                       AppendPayload (const AJAAncillaryData & inAncData);

    virtual inline NTV2_DEPRECATED_f(AJAStatus  AppendPayload (const AJAAncillaryData * pInAncData))    {return pInAncData ? AppendPayload (*pInAncData) : AJA_STATUS_NULL;}

    virtual AJAStatus                       SetFromSMPTE334 (const uint16_t * pInData, const uint32_t inNumWords, const AJAAncDataLoc & inLocInfo);

    virtual AJAStatus                       ParsePayloadData (void);

    virtual inline bool                     GotValidReceiveData (void) const            {return m_rcvDataValid;}

    virtual inline AJAStatus                GeneratePayloadData (void)                  {return AJA_STATUS_SUCCESS;}



    virtual AJAStatus                       InitWithReceivedData (  const uint8_t *         pInData,
                                                                    const size_t            inMaxBytes,
                                                                    const AJAAncDataLoc &   inLocationInfo,
                                                                    uint32_t &              outPacketByteCount);
    virtual AJAStatus                       InitAuxWithReceivedData (   const uint8_t *         pInData,
                                                                    const size_t            inMaxBytes,
                                                                    //const AJAAncDataLoc & inLocationInfo,
                                                                    uint32_t &              outPacketByteCount);

    virtual AJAStatus                       InitWithReceivedData (  const std::vector<uint8_t> &    inData,
                                                                    const AJAAncDataLoc &           inLocationInfo);

    virtual AJAStatus                       InitWithReceivedData (const ULWordSequence & inData, uint16_t & inOutStartIndex, const bool inIgnoreChecksum = false);



    virtual AJAStatus                       GetRawPacketSize (uint32_t & outPacketSize) const;

    virtual AJAStatus                       GenerateTransmitData (uint8_t * pBuffer, const size_t inMaxBytes, uint32_t & outPacketSize);

    virtual AJAStatus                       GenerateTransmitData (UWordSequence & outData);

    virtual AJAStatus                       GenerateTransmitData (ULWordSequence & outData);



    virtual std::ostream &                  Print (std::ostream & inOutStream, const bool inDetailed = false) const;

    virtual std::ostream &                  DumpPayload (std::ostream & inOutStream) const;

    virtual std::string                     CompareWithInfo (const AJAAncillaryData & inRHS, const bool inIgnoreLocation = true, const bool inIgnoreChecksum = true) const;

    virtual std::string                     IDAsString (void) const;    

    virtual std::string                     AsString (const uint16_t inDumpMaxBytes = 0) const;
    
    static std::string                      DIDSIDToString (const uint8_t inDID, const uint8_t inSDID);

    static std::string                      AuxPacketTypeToString (const uint8_t inAuxPktType);

    static bool                             AuxPacketTypeIsValid (const uint8_t inAuxPktType);




    static uint16_t                         AddEvenParity (const uint8_t inDataByte);


    typedef UWordSequence           U16Packet;  
    typedef std::vector<U16Packet>  U16Packets; 

    static bool                             GetAncPacketsFromVANCLine (const UWordSequence &            inYUV16Line,
                                                                        const AncChannelSearchSelect    inChanSelect,
                                                                        U16Packets &                    outRawPackets,
                                                                        U16Packet &                     outWordOffsets);
    static bool                             Unpack8BitYCbCrToU16sVANCLine (const void * pInYUV8Line,
                                                                            U16Packet & outU16YUVLine,
                                                                            const uint32_t inNumPixels);
    static bool                             Unpack8BitYCbCrToU16sVANCLineSD (const void * pInYUV8Line,
                                                                            UWordSequence & outU16YUVLine,
                                                                            const uint32_t inNumPixels);

    static void                             GetInstanceCounts (uint32_t & outConstructed, uint32_t & outDestructed);
    static uint32_t                         GetNumActiveInstances (void);
    static uint32_t                         GetNumConstructed (void);
    static uint32_t                         GetNumDestructed (void);
    static void                             ResetInstanceCounts (void);

    protected:
        typedef std::vector<uint8_t>        ByteVector;
        typedef ByteVector::size_type       ByteVectorIndex;
        typedef ByteVector::const_iterator  ByteVectorConstIter;

        void                                Init (void);    // NOT virtual - called by constructors

        AJAStatus                           AllocDataMemory (const uint32_t inNumBytes);
        AJAStatus                           FreeDataMemory (void);

        static inline uint8_t               GetGUMPHeaderByte1 (void)           {return 0xFF;}
        virtual uint8_t                     GetGUMPHeaderByte2 (void) const;
        virtual inline uint8_t              GetGUMPHeaderByte3 (void) const     {return GetLocationLineNumber() & 0x7F;}    // ls 7 bits [6:0] of line num

    //  Instance Data
    protected:
        uint8_t             m_DID;          
        uint8_t             m_SID;          
        uint8_t             m_checksum;     
        AJAAncDataLoc       m_location;     
        AJAAncDataCoding    m_coding;       
        ByteVector          m_payload;      
        bool                m_rcvDataValid; 
        AJAAncDataType      m_ancType;      
        AJAAncBufferFormat  m_bufferFmt;    
        uint32_t            m_frameID;      
        uint64_t            m_userData;     
        //HDMI Aux specific types   
        uint8_t             m_auxType;      
        uint8_t             m_auxHB1;       
        uint8_t             m_auxHB2;       

};  //  AJAAncillaryData

typedef AJAAncillaryData    AJAAuxiliaryData, AJAAncPacket, AJAAuxPacket, AJAAncData, AJAAuxData;


static inline std::ostream & operator << (std::ostream & inOutStream, const AJAAncillaryData & inAncData)       {return inAncData.Print(inOutStream);}


class AJAExport AJARTPAncPayloadHeader
{
    public: // CLASS METHODS

        static bool             BufferStartsWithRTPHeader (const NTV2Buffer & inBuffer);

        static inline size_t    GetHeaderWordCount (void)   {return 5;}                                         
        static inline size_t    GetHeaderByteCount (void)   {return GetHeaderWordCount() * sizeof(uint32_t);}   

        static const std::string &  FieldSignalToString (const uint8_t inFBits);


    public: // INSTANCE METHODS
                                AJARTPAncPayloadHeader ();      
        virtual inline          ~AJARTPAncPayloadHeader ()  {}  

        virtual bool            IsNULL (void) const;                                                
        virtual bool            IsValid (void) const;                                               
        virtual inline bool     IsEndOfFieldOrFrame (void) const    {return mMarkerBit;}            
        virtual inline uint8_t  GetPayloadType (void) const         {return mPayloadType;}          
        virtual inline uint32_t GetSequenceNumber (void) const      {return mSequenceNumber;}       
        virtual inline uint32_t GetTimeStamp (void) const           {return mTimeStamp;}            
        virtual inline uint32_t GetSyncSourceID (void) const        {return mSyncSourceID;}         
        virtual inline uint16_t GetPayloadLength (void) const       {return mPayloadLength;}        
        virtual inline uint8_t  GetAncPacketCount (void) const      {return mAncCount;}             
        virtual inline uint8_t  GetFieldSignal (void) const         {return mFieldSignal & 3;}      
        virtual inline bool     IsProgressive (void) const          {return mFieldSignal == 0;}     
        virtual inline bool     NoFieldSpecified (void) const       {return IsProgressive();}       
        virtual inline bool     IsField1 (void) const               {return mFieldSignal == 2;}     
        virtual inline bool     IsField2 (void) const               {return mFieldSignal == 3;}     
        virtual inline bool     IsValidFieldSignal (void) const     {return mFieldSignal != 1;}     
        virtual inline bool     HasPaddingBytes (void) const        {return mPBit;}                 
        virtual inline bool     HasExtendedHeader (void) const      {return mXBit;}                 

        virtual bool            operator == (const AJARTPAncPayloadHeader & inRHS) const;

        virtual inline bool     operator != (const AJARTPAncPayloadHeader & inRHS) const    {return !(operator == (inRHS));}

        virtual std::ostream &  Print (std::ostream & inOutStream) const;


        virtual bool            WriteToULWordVector (ULWordSequence & outVector, const bool inReset = true) const;

        virtual bool            WriteToBuffer (NTV2Buffer & outBuffer, const ULWord inU32Offset = 0) const;

        virtual bool            ReadFromULWordVector (const ULWordSequence & inVector);

        virtual bool            ReadFromBuffer (const NTV2Buffer & inBuffer);


        virtual inline AJARTPAncPayloadHeader & SetField1 (void)                                    {return SetFieldSignal(2);}

        virtual inline AJARTPAncPayloadHeader & SetField2 (void)                                    {return SetFieldSignal(3);}

        virtual inline AJARTPAncPayloadHeader & SetProgressive (void)                               {return SetFieldSignal(0);}

        virtual inline AJARTPAncPayloadHeader & SetPayloadType (const uint8_t inPayloadType)        {mPayloadType = inPayloadType & 0x7F;  return *this;}

        virtual inline AJARTPAncPayloadHeader & SetPayloadLength (const uint16_t inByteCount)       {mPayloadLength     = inByteCount;      return *this;}

        virtual inline AJARTPAncPayloadHeader & SetAncPacketCount (const uint8_t inPktCount)        {mAncCount          = inPktCount;       return *this;}

        virtual inline AJARTPAncPayloadHeader & SetTimeStamp (const uint32_t inTimeStamp)           {mTimeStamp         = inTimeStamp;      return *this;}

        virtual inline AJARTPAncPayloadHeader & SetSyncSourceID (const uint32_t inSyncSrcID)        {mSyncSourceID      = inSyncSrcID;      return *this;}

        virtual inline AJARTPAncPayloadHeader & SetSequenceNumber (const uint32_t inSeqNumber)      {mSequenceNumber    = inSeqNumber;      return *this;}

        virtual inline AJARTPAncPayloadHeader & SetCCBits (const uint8_t inCCBits)                  {mCCBits            = inCCBits & 0x0F;  return *this;}

        virtual inline AJARTPAncPayloadHeader & SetEndOfFieldOrFrame (const bool inIsLast = true)   {mMarkerBit         = inIsLast;         return *this;}

    protected:
        virtual bool                            SetFromPacketHeaderULWordAtIndex (const unsigned inIndex0, const uint32_t inULWord);

        virtual inline AJARTPAncPayloadHeader & SetFieldSignal (const uint8_t inFieldSignal)    {mFieldSignal = (inFieldSignal & 0x03);  return *this;}

        virtual bool            GetPacketHeaderULWordForIndex (const unsigned inIndex0, uint32_t & outULWord) const;

        virtual inline uint32_t GetPacketHeaderULWordForIndex (const unsigned inIndex0) const       {uint32_t result(0); GetPacketHeaderULWordForIndex(inIndex0, result); return result;}

    private: // INSTANCE DATA
        uint8_t     mVBits;         
        bool        mPBit;          
        bool        mXBit;          
        bool        mMarkerBit;     
        uint8_t     mCCBits;        
        uint8_t     mPayloadType;   
        uint32_t    mSequenceNumber;
        uint32_t    mTimeStamp;     
        uint32_t    mSyncSourceID;  
        uint16_t    mPayloadLength; 
        uint8_t     mAncCount;      
        uint8_t     mFieldSignal;   
};  //  AJARTPAncPayloadHeader

static inline std::ostream & operator << (std::ostream & inOutStrm,  const AJARTPAncPayloadHeader & inObj)  {return inObj.Print(inOutStrm);}


class AJAExport AJARTPAncPacketHeader
{
    public:  // INSTANCE METHODS
                                AJARTPAncPacketHeader ();       
        explicit                AJARTPAncPacketHeader (const AJAAncDataLoc & inLocation);   
        virtual inline          ~AJARTPAncPacketHeader ()       {}      

        virtual uint32_t        GetULWord (void) const;                                     
        virtual inline bool     IsCBitSet (void) const              {return mCBit;}         
        virtual inline bool     IsSBitSet (void) const              {return mSBit;}         
        virtual inline uint16_t GetLineNumber (void) const          {return mLineNum;}      
        virtual inline uint16_t GetHorizOffset (void) const         {return mHOffset;}      
        virtual inline uint8_t  GetStreamNumber (void) const        {return mStreamNum;}    
        virtual AJAAncDataLoc   AsDataLocation(void) const;                                 

        virtual std::ostream &      Print (std::ostream & inOutStream) const;


        virtual inline AJARTPAncPacketHeader &  SetCChannel (void)                          {mCBit = true;  return *this;}

        virtual inline AJARTPAncPacketHeader &  SetYChannel (void)                          {mCBit = false;  return *this;}

        virtual inline AJARTPAncPacketHeader &  SetLineNumber (const uint16_t inLineNum)        {mLineNum = inLineNum & 0x7FF;  return *this;}

        virtual inline AJARTPAncPacketHeader &  SetHorizOffset (const uint16_t inHOffset)   {mHOffset = inHOffset & 0x0FFF;  return *this;}

        virtual inline AJARTPAncPacketHeader &  SetStreamNumber (const uint8_t inStreamNum) {mStreamNum = inStreamNum & 0x07F;  return *this;}

        virtual inline AJARTPAncPacketHeader &  SetDataStreamFlag (const bool inFlag)       {mSBit = inFlag;  return *this;}

        virtual AJARTPAncPacketHeader & SetFrom (const AJAAncDataLoc & inLocation);

        virtual inline AJARTPAncPacketHeader &  operator = (const AJAAncDataLoc & inRHS)        {return SetFrom(inRHS);}


        virtual bool            SetFromULWord (const uint32_t inULWord);

        virtual bool            ReadFromULWordVector (const ULWordSequence & inVector, const unsigned inIndex0);

        virtual bool    WriteToULWordVector (ULWordSequence & outVector,  const bool inReset = true) const;

    private:  // INSTANCE DATA
        bool        mCBit;      
        bool        mSBit;      
        uint16_t    mLineNum;   
        uint16_t    mHOffset;   
        uint8_t     mStreamNum; 
};  //  AJARTPAncPacketHeader

static inline std::ostream & operator << (std::ostream & inOutStrm,  const AJARTPAncPacketHeader & inObj)   {return inObj.Print(inOutStrm);}


#if !defined(NTV2_DEPRECATE_16_3)
    //  The old, original long names...
    typedef AJAAncDataSpace                             AJAAncillaryDataSpace;
    typedef AJAAncDataStream                            AJAAncillaryDataStream;
    typedef AJAAncDataLink                              AJAAncillaryDataLink;
    typedef AJAAncDataType                              AJAAncillaryDataType;
    typedef AJAAncDataLoc                               AJAAncillaryDataLocation;
    typedef AJAAncillaryDataLocation *                  AJAAncillaryDataLocationPtr;
    typedef AJAAncDataCoding                            AJAAncillaryDataCoding;
    typedef AJAAncBufferFormat                          AJAAncillaryBufferFormat;
    typedef AJAAncDataChannel                           AJAAncillaryDataChannel;
//  typedef AJAAncillaryDataChannel                     AJAAncDataChannel;
    typedef AJAAncillaryDataChannel                     AJAAncillaryDataVideoStream;

    AJAExport inline const std::string & AJAAncillaryDataVideoStreamToString (const AJAAncillaryDataVideoStream inValue, const bool inCompact = true)
    {
        return AJAAncDataChannelToString(inValue,inCompact);
    }

    #define AJAAncillaryDataChannel_C                   AJAAncDataChannel_C
    #define AJAAncillaryDataChannel_Both                AJAAncDataChannel_Both
    #define AJAAncillaryDataChannel_Y                   AJAAncDataChannel_Y
    #define AJAAncillaryDataChannel_Unknown             AJAAncDataChannel_Unknown
    #define AJAAncillaryDataChannel_Size                AJAAncDataChannel_Size
    #define IS_VALID_AJAAncillaryDataVideoStream(_x_)   (IS_VALID_AJAAncDataChannel(_x_))
    #define AJAAncillaryDataVideoStream_C               AJAAncillaryDataChannel_C
    #define AJAAncillaryDataVideoStream_Y               AJAAncillaryDataChannel_Y
    #define AJAAncillaryDataVideoStream_Unknown         AJAAncillaryDataChannel_Unknown
    #define AJAAncillaryDataVideoStream_Size            AJAAncillaryDataChannel_Size
    #define IS_VALID_AJAAncillaryDataChannel            IS_VALID_AJAAncDataChannel
    #define AJAAncillaryDataChannelToString             AJAAncDataChannelToString

    #define AJAAncillaryDataSpace_VANC                  AJAAncDataSpace_VANC
    #define AJAAncillaryDataSpace_HANC                  AJAAncDataSpace_HANC
    #define AJAAncillaryDataSpace_Unknown               AJAAncDataSpace_Unknown
    #define AJAAncillaryDataSpace_Size                  AJAAncDataSpace_Size
    #define IS_VALID_AJAAncillaryDataSpace              IS_VALID_AJAAncDataSpace
    #define IS_HANC_AJAAncillaryDataSpace               IS_HANC_AJAAncDataSpace
    #define IS_VANC_AJAAncillaryDataSpace               IS_VANC_AJAAncDataSpace
    #define AJAAncillaryDataSpaceToString               AJAAncDataSpaceToString

    #define AJAAncillaryDataStream_1                    AJAAncDataStream_1
    #define AJAAncillaryDataStream_2                    AJAAncDataStream_2
    #define AJAAncillaryDataStream_3                    AJAAncDataStream_3
    #define AJAAncillaryDataStream_4                    AJAAncDataStream_4
    #define AJAAncillaryDataStream_Unknown              AJAAncDataStream_Unknown
    #define AJAAncillaryDataStream_Size                 AJAAncDataStream_Size
    #define IS_VALID_AJAAncillaryDataStream             IS_VALID_AJAAncDataStream
    #define IS_LINKA_AJAAncillaryDataStream             IS_LINKA_AJAAncDataStream
    #define IS_LINKB_AJAAncillaryDataStream             IS_LINKB_AJAAncDataStream
    #define AJAAncillaryDataStreamToString              AJAAncDataStreamToString

    #define AJAAncillaryDataLink_A                      AJAAncDataLink_A
    #define AJAAncillaryDataLink_B                      AJAAncDataLink_B
    #define AJAAncillaryDataLink_LeftEye                AJAAncDataLink_LeftEye
    #define AJAAncillaryDataLink_RightEye               AJAAncDataLink_RightEye
    #define AJAAncillaryDataLink_Unknown                AJAAncDataLink_Unknown
    #define AJAAncillaryDataLink_Size                   AJAAncDataLink_Size
    #define IS_VALID_AJAAncillaryDataLink               IS_VALID_AJAAncDataLink
    #define AJAAncillaryDataLinkToString                AJAAncDataLinkToString

    #define AJAAncillaryDataType_Unknown                AJAAncDataType_Unknown
    #define AJAAncillaryDataType_Smpte2016_3            AJAAncDataType_Smpte2016_3
    #define AJAAncillaryDataType_Timecode_ATC           AJAAncDataType_Timecode_ATC
    #define AJAAncillaryDataType_Timecode_VITC          AJAAncDataType_Timecode_VITC
    #define AJAAncillaryDataType_Cea708                 AJAAncDataType_Cea708
    #define AJAAncillaryDataType_Cea608_Vanc            AJAAncDataType_Cea608_Vanc
    #define AJAAncillaryDataType_Cea608_Line21          AJAAncDataType_Cea608_Line21
    #define AJAAncillaryDataType_Smpte352               AJAAncDataType_Smpte352
    #define AJAAncillaryDataType_Smpte2051              AJAAncDataType_Smpte2051
    #define AJAAncillaryDataType_FrameStatusInfo524D    AJAAncDataType_FrameStatusInfo524D
    #define AJAAncillaryDataType_FrameStatusInfo5251    AJAAncDataType_FrameStatusInfo5251
    #define AJAAncillaryDataType_HDR_SDR                AJAAncDataType_HDR_SDR
    #define AJAAncillaryDataType_HDR_HDR10              AJAAncDataType_HDR_HDR10
    #define AJAAncillaryDataType_HDR_HLG                AJAAncDataType_HDR_HLG
    #define AJAAncillaryDataType_Size                   AJAAncDataType_Size
    #define IS_VALID_AJAAncillaryDataType               IS_VALID_AJAAncDataType
    #define IS_KNOWN_AJAAncillaryDataType               IS_KNOWN_AJAAncDataType
    #define AJAAncillaryDataTypeToString                AJAAncDataTypeToString
    #define AJAAncillaryData_AnalogDID                  AJAAncData_AnalogDID
    #define AJAAncillaryData_AnalogSID                  AJAAncData_AnalogSID

    #define AJAAncillaryDataCoding_Digital              AJAAncDataCoding_Digital
    #define AJAAncillaryDataCoding_Raw                  AJAAncDataCoding_Raw
    #define AJAAncillaryDataCoding_Analog               AJAAncDataCoding_Raw
    #define AJAAncillaryDataCoding_Unknown              AJAAncDataCoding_Unknown
    #define AJAAncillaryDataCoding_Size                 AJAAncDataCoding_Size
    #define IS_VALID_AJAAncillaryDataCoding(_x_)        IS_VALID_AJAAncDataCoding(_x_)
    #define AJAAncillaryDataCodingToString              AJAAncDataCodingToString

    #define AJAAncillaryBufferFormat_Unknown            AJAAncBufferFormat_Unknown
    #define AJAAncillaryBufferFormat_FBVANC             AJAAncBufferFormat_FBVANC
    #define AJAAncillaryBufferFormat_SDI                AJAAncBufferFormat_SDI
    #define AJAAncillaryBufferFormat_RTP                AJAAncBufferFormat_RTP
    #define AJAAncillaryBufferFormat_Invalid            AJAAncBufferFormat_Invalid
    #define AJAAncillaryBufferFormat_Size               AJAAncBufferFormat_Invalid
    #define IS_VALID_AJAAncillaryBufferFormat(_x_)      IS_VALID_AJAAncBufferFormat(_x_)
    #define IS_KNOWN_AJAAncillaryBufferFormat(_x_)      IS_KNOWN_AJAAncBufferFormat(_x_)
    #define AJAAncillaryBufferFormatToString            AJAAncBufferFormatToString
#endif  //  !defined(NTV2_DEPRECATE_16_3)

#endif  // AJA_ANCILLARYDATA_H