ntv2registerexpert.h

Go to the documentation of this file.

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

#include "ajaexport.h"
#include "ajatypes.h"
#include "ntv2enums.h"
#include "ntv2publicinterface.h"
#include "ntv2utils.h"
#include <string>
#include <iostream>
#include <vector>
#if defined (AJALinux)
    #include <stdint.h>
#endif


//  Streaming Helpers
#define YesNo(__x__)                    ((__x__) ? "Y"              : "N")
#define OnOff(__x__)                    ((__x__) ? "On"             : "Off")
#define SetNotset(__x__)                ((__x__) ? "Set"            : "Not Set")
#define EnabDisab(__x__)                ((__x__) ? "Enabled"        : "Disabled")
#define OddEven(__x__)                  ((__x__) ? "Odd"            : "Even")
#define DisabEnab(__x__)                ((__x__) ? "Disabled"       : "Enabled")
#define ActInact(__x__)                 ((__x__) ? "Active"         : "Inactive")
#define SuppNotsupp(__x__)              ((__x__) ? "Supported"      : "Unsupported")
#define PresNotPres(__x__)              ((__x__) ? "Present"        : "Not Present")
#define ThruDeviceOrBypassed(__x__)     ((__x__) ? "Thru Device"    : "Device Bypassed")


//  Register classifier keys
#define kRegClass_NULL              std::string ()
#define kRegClass_AES               std::string ("kRegClass_AES")
#define kRegClass_Analog            std::string ("kRegClass_Analog")
#define kRegClass_Anc               std::string ("kRegClass_Anc")
#define kRegClass_Audio             std::string ("kRegClass_Audio")
#define kRegClass_Aux               std::string ("kRegClass_Aux")
#define kRegClass_Channel1          std::string ("kRegClass_Channel1")
#define kRegClass_Channel2          std::string ("kRegClass_Channel2")
#define kRegClass_Channel3          std::string ("kRegClass_Channel3")
#define kRegClass_Channel4          std::string ("kRegClass_Channel4")
#define kRegClass_Channel5          std::string ("kRegClass_Channel5")
#define kRegClass_Channel6          std::string ("kRegClass_Channel6")
#define kRegClass_Channel7          std::string ("kRegClass_Channel7")
#define kRegClass_Channel8          std::string ("kRegClass_Channel8")
#define kRegClass_CSC               std::string ("kRegClass_CSC")
#define kRegClass_DMA               std::string ("kRegClass_DMA")
#define kRegClass_HDMI              std::string ("kRegClass_HDMI")
#define kRegClass_HDR               std::string ("kRegClass_HDR")
#define kRegClass_Input             std::string ("kRegClass_Input")
#define kRegClass_Info              std::string ("kRegClass_Info")
#define kRegClass_Interrupt         std::string ("kRegClass_Interrupt")
#define kRegClass_IP                std::string ("kRegClass_IP")
#define kRegClass_LUT               std::string ("kRegClass_LUT")
#define kRegClass_Mixer             std::string ("kRegClass_Mixer")
#define kRegClass_Output            std::string ("kRegClass_Output")
#define kRegClass_ReadOnly          std::string ("kRegClass_ReadOnly")
#define kRegClass_Routing           std::string ("kRegClass_Routing")
#define kRegClass_SDIError          std::string ("kRegClass_SDIError")
#define kRegClass_Serial            std::string ("kRegClass_Serial")
#define kRegClass_Timecode          std::string ("kRegClass_Timecode")
#define kRegClass_Timing            std::string ("kRegClass_Timing")
#define kRegClass_Video             std::string ("kRegClass_Video")
#define kRegClass_Virtual           std::string ("kRegClass_Virtual")
#define kRegClass_VPID              std::string ("kRegClass_VPID")
#define kRegClass_WriteOnly         std::string ("kRegClass_WriteOnly")
#define kRegClass_XptROM            std::string ("kRegClass_XptROM")
#define kRegClass_NTV4FrameStore    std::string ("kRegClass_NTV4FrameStore")


#define kIncludeOtherRegs_None      0
#define kIncludeOtherRegs_VRegs     1       //  Also include virtual regs
#define kIncludeOtherRegs_XptROM    2       //  Also include crosspoint ROM regs


class AJAExport CNTV2RegisterExpert
{
    public:
        static std::string      GetDisplayName  (const uint32_t inRegNum);

        static std::string      GetDisplayValue (const uint32_t inRegNum, const uint32_t inRegValue, const NTV2DeviceID inDeviceID = DEVICE_ID_NOTFOUND);

        static bool             IsRegisterInClass (const uint32_t inRegNum, const std::string & inClassName);

        static inline bool      IsReadOnly      (const uint32_t inRegNum)   {return IsRegisterInClass (inRegNum, kRegClass_ReadOnly);}

        static inline bool      IsWriteOnly     (const uint32_t inRegNum)   {return IsRegisterInClass (inRegNum, kRegClass_WriteOnly);}

        static NTV2StringSet    GetAllRegisterClasses (void);

        static NTV2StringSet    GetRegisterClasses (const uint32_t inRegNum, const bool inRemovePrefix = false);

        static NTV2RegNumSet    GetRegistersForClass    (const std::string & inClassName);

        static NTV2RegNumSet    GetRegistersForChannel  (const NTV2Channel inChannel);

        static NTV2RegNumSet    GetRegistersForDevice (const NTV2DeviceID inDeviceID, const int inOtherRegsToInclude = kIncludeOtherRegs_None);

        static NTV2RegNumSet    GetRegistersWithName (const std::string & inName, const int inSearchStyle = EXACTMATCH);

        static NTV2InputCrosspointID    GetInputCrosspointID (const uint32_t inXptRegNum, const uint32_t inMaskIndex);

        static bool                     GetCrosspointSelectGroupRegisterInfo (const NTV2InputCrosspointID inInputXpt, uint32_t & outXptRegNum, uint32_t & outMaskIndex);

        static const int    CONTAINS    =   0;  
        static const int    STARTSWITH  =   1;  
        static const int    ENDSWITH    =   2;  
        static const int    EXACTMATCH  =   3;  
        static bool         IsAllocated(void);  

        static bool Allocate(void);

        static bool Deallocate(void);

};  //  CNTV2RegisterExpert

#endif  //  NTV2REGEXPERT_H