ntv2card.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#include "ntv2devicefeatures.h"
#include "ntv2card.h"
#include "ntv2debug.h"
#include "ntv2utils.h"
#include <sstream>
#include "ajabase/common/common.h"
#include "ajabase/system/info.h"    //  for AJASystemInfo

using namespace std;


// Default Constructor
CNTV2Card::CNTV2Card ()
    :   mDevCap(driverInterface())
{
    _boardOpened = false;
}

CNTV2Card::CNTV2Card (const UWord inDeviceIndex, const string & inHostName)
    :   mDevCap(driverInterface())
{
    string hostName(inHostName);
    aja::strip(hostName);
    _boardOpened = false;
    bool openOK = hostName.empty()  ?  CNTV2DriverInterface::Open(inDeviceIndex) :  CNTV2DriverInterface::Open(hostName);
    if (openOK)
    {
#if !defined(NTV2_DEPRECATE_17_2)
        if (IsBufferSizeSetBySW())
        {
            NTV2Framesize fbSize;
            GetFrameBufferSize (NTV2_CHANNEL1, fbSize);
            SetFrameBufferSize (fbSize);
        }
        else
        {
            NTV2FrameGeometry fg;
            NTV2FrameBufferFormat format;

            GetFrameGeometry (fg);
            GetFrameBufferFormat (NTV2_CHANNEL1, format);

            _ulFrameBufferSize = ::NTV2DeviceGetFrameBufferSize (GetDeviceID (), fg, format);
            _ulNumFrameBuffers = ::NTV2DeviceGetNumberFrameBuffers (GetDeviceID (), fg, format);
        }
#endif
    }
}

// Destructor
CNTV2Card::~CNTV2Card ()
{
    if (IsOpen ())
        Close ();

}   //  destructor


Word CNTV2Card::GetDeviceVersion (void)
{
    ULWord  status  (0);
    return ReadRegister (kRegStatus, status) ? (status & 0xF) : -1;
}


string CNTV2Card::GetDeviceVersionString (void)
{
    ostringstream   oss;
    oss << ::NTV2DeviceIDToString(GetDeviceID());
    return oss.str();
}


string CNTV2Card::GetModelName (void)
{
    return ::NTV2DeviceIDToString(GetDeviceID(), /*retail?*/ GetDeviceID() == DEVICE_ID_IO4KPLUS
                                                            &&  IsSupported(kDeviceHasMicrophoneInput));
}

string CNTV2Card::GetDisplayName (void)
{
    ostringstream oss;
    if (IsRemote())
    {
        const NTV2Dictionary params (ConnectParams());
        string fName (params.valueForKey(kQParamVDevName)),
                devNdx (params.valueForKey(kQParamVDevIndex)),
                model (GetModelName());
        if (model == "Software" || model == "AJA Device" || model == "(Not Found)" || model == "Unknown" || model == "???")
            model = fName.empty() ? params.valueForKey(kNTV2PluginRegInfoKey_ShortName) : fName;
        if (devNdx.empty())
            {ostringstream tmp;  tmp << GetIndexNumber();  devNdx = tmp.str();}
        oss << model << " - " << devNdx;
    }
    else
        oss << GetModelName() << " - " << GetIndexNumber();
    return oss.str();
}


string CNTV2Card::GetFPGAVersionString (const NTV2XilinxFPGA inFPGA)
{
    ULWord          numBytes    (0);
    string          dateStr, timeStr;
    ostringstream   oss;

    if (inFPGA == eFPGAVideoProc && GetInstalledBitfileInfo (numBytes, dateStr, timeStr))
        oss << dateStr << " at " << timeStr;
    else
        oss << "Unavailable";

    return oss.str ();
}


Word CNTV2Card::GetPCIFPGAVersion (void)
{
    ULWord  status  (0);
    return ReadRegister (48, status) ? ((status >> 8) & 0xFF) : -1;
}


string CNTV2Card::GetPCIFPGAVersionString (void)
{
    const UWord     version (static_cast<UWord>(GetPCIFPGAVersion()));
    ostringstream   oss;
    oss << hex << version;
    return oss.str ();
}

string CNTV2Card::GetDescription (void) const
{
    if (!IsOpen())
        return string();
    if (IsRemote())
        return CNTV2DriverInterface::GetDescription();

    CNTV2Card * pCard = (CNTV2Card*)(this); //  Ugly: *sigh* If only most CNTV2Card member functions were 'const'
    ostringstream oss;
    string hostName("localhost"), snStr;
    AJASystemInfo sysInfo (AJA_SystemInfoMemoryUnit_Megabytes, AJA_SystemInfoSection_System);
    sysInfo.GetValue(AJA_SystemInfoTag_System_Name, hostName);
    oss << pCard->GetModelName();
    if (!pCard->GetSerialNumberString(snStr))
        snStr.clear();
    if (!snStr.empty())
        oss << " '" << snStr << "'";
    if (!hostName.empty())
        oss << " on '" << hostName << "'";
    oss << " at index " << DEC(GetIndexNumber());
    return oss.str();
}

string CNTV2Card::GetDriverVersionString (void)
{
    static const string sDriverBuildTypes []    = {"", "b", "a", "d"};
    UWord               versions[4]             = {0, 0, 0, 0};
    ULWord              versBits(0);
    if (!GetDriverVersionComponents (versions[0], versions[1], versions[2], versions[3]))
        return string();    //  fail
    if (!ReadRegister (kVRegDriverVersion, versBits))
        return string();    //  fail

    const string & dabr (sDriverBuildTypes[versBits >> 30]);    //  Bits 31:30 == build type
    ostringstream oss;
    oss << DEC(versions[0]) << "." << DEC(versions[1]) << "." << DEC(versions[2]);
    if (dabr.empty())
        oss << "." << DEC(versions[3]);
    else
        oss << dabr << DEC(versions[3]);
    return oss.str();

}   //  GetDriverVersionString


bool CNTV2Card::GetDriverVersionComponents (UWord & outMajor, UWord & outMinor, UWord & outPoint, UWord & outBuild)
{
    outMajor = outMinor = outPoint = outBuild = 0;
    ULWord  driverVersionULWord (0);
    if (!ReadRegister (kVRegDriverVersion, driverVersionULWord))
        return false;
    if (!driverVersionULWord)   //  If zero --- pre-15.0 driver?
        return false;

    //  The normal 15.0+ way of decoding the 32-bit driver version value:
    outMajor = UWord(NTV2DriverVersionDecode_Major(driverVersionULWord));
    outMinor = UWord(NTV2DriverVersionDecode_Minor(driverVersionULWord));
    outPoint = UWord(NTV2DriverVersionDecode_Point(driverVersionULWord));
    outBuild = UWord(NTV2DriverVersionDecode_Build(driverVersionULWord));
    return true;
}


ULWord CNTV2Card::GetSerialNumberLow (void)
{
    ULWord  serialNum   (0);
    return ReadRegister (kRegReserved54, serialNum) ? serialNum : 0;    //  Read EEPROM shadow of Serial Number
}


ULWord CNTV2Card::GetSerialNumberHigh (void)
{
    ULWord  serialNum   (0);
    return ReadRegister (kRegReserved55, serialNum) ? serialNum : 0;    //  Read EEPROM shadow of Serial Number
}

uint64_t CNTV2Card::GetSerialNumber (void)
{
    const uint64_t  lo(GetSerialNumberLow()),   hi(GetSerialNumberHigh());
    const uint64_t  result((hi << 32) | lo);
    return result;
}


string CNTV2Card::SerialNum64ToString (const uint64_t inSerialNumber)   //  Class method
{
    return ::SerialNum64ToString(inSerialNumber);
}   //  SerialNum64ToString


bool CNTV2Card::GetSerialNumberString (string & outSerialNumberString)
{
    ULWord spiFlashVers(0);
    const bool hasLPPC(IsSupported(kDeviceHasLPProductCode));
    if (hasLPPC  ||  (GetNumericParam(kDeviceGetSPIFlashVersion, spiFlashVers) && spiFlashVers >= 6))
    {
        //  Newer devices use 4 regs:  kRegReserved54 thru kRegReserved57
        ULWord serialArray[] = {0,0,0,0};
        ReadRegister(hasLPPC ? kRegReserved54 : kRegReserved56, serialArray[0]);
        ReadRegister(hasLPPC ? kRegReserved55 : kRegReserved57, serialArray[1]);
        ReadRegister(hasLPPC ? kRegReserved56 : kRegReserved54, serialArray[2]);
        ReadRegister(hasLPPC ? kRegReserved57 : kRegReserved55, serialArray[3]);
        outSerialNumberString.clear();
        for (int serialIndex = 0;  serialIndex < 4;  serialIndex++)
            if (serialArray[serialIndex] != 0xffffffff)
                for (int i = 0;  i < 4;  i++)
                {
                    const char tempChar(((serialArray[serialIndex] >> (i*8)) & 0xff));
                    if (tempChar > 0 && tempChar != '.')
                        outSerialNumberString.push_back(tempChar);
                }
    }
    else
    {   //  Older devices use 2 regs:  kRegReserved54 & kRegReserved55
        outSerialNumberString = ::SerialNum64ToString(GetSerialNumber());
        if (outSerialNumberString.empty())
            {outSerialNumberString = "INVALID?";  return false;}

        //  Prepend 5/6/7 for Io4K+/IoIP/IoX3, respectively...
        const NTV2DeviceID deviceID (GetDeviceID());
        if (deviceID == DEVICE_ID_IO4KPLUS)
            outSerialNumberString = "5" + outSerialNumberString;    //  Io4K+/DNXIV: prepend "5"
        else if (deviceID == DEVICE_ID_IOIP_2022 ||
                 deviceID == DEVICE_ID_IOIP_2110 ||
                 deviceID == DEVICE_ID_IOIP_2110_RGB12)
            outSerialNumberString = "6" + outSerialNumberString;    //  IoIP: prepend "6"
        else if (deviceID == DEVICE_ID_IOX3)
            outSerialNumberString = "7" + outSerialNumberString;    //  IoX3: prepend "7"
    }
    return true;
}   //  GetSerialNumberString


bool CNTV2Card::IS_CHANNEL_INVALID (const NTV2Channel inChannel) const
{
    if (!NTV2_IS_VALID_CHANNEL (inChannel))
        return true;
    return false;
}


bool CNTV2Card::IS_OUTPUT_SPIGOT_INVALID (const UWord inOutputSpigot)
{
    if (inOutputSpigot >= UWord(GetNumSupported(kDeviceGetNumVideoOutputs)))
    {
        const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_WidgetID));
        if (itms.find(ULWord(NTV2_WgtSDIMonOut1)) != itms.end()  &&  inOutputSpigot == 4)
            return false;   //  Io4K Monitor Output exception
        return true;        //  Invalid
    }
    return false;
}


bool CNTV2Card::IS_INPUT_SPIGOT_INVALID (const UWord inInputSpigot)
{
    if (inInputSpigot >= UWord(GetNumSupported(kDeviceGetNumVideoInputs)))
        return true;
    return false;
}

bool CNTV2Card::IS_HDMI_INPUT_SPIGOT_INVALID (const UWord inInputHDMIPort)
{
    if (inInputHDMIPort >= UWord(GetNumSupported(kDeviceGetNumHDMIVideoInputs)))
        return true;
    return false;
}

ULWord CNTV2Card::DeviceGetNumberFrameBuffers (void)
{
    if (IsSupported(kDeviceCanDoStackedAudio))
    {
        ULWord totalFrames = GetNumSupported(kDeviceGetActiveMemorySize) / 0x800000;
        totalFrames -= GetNumSupported(kDeviceGetNumAudioSystems) * (IsSupported(kDeviceCanDo12gRouting) ? 4 : 1);
        if (_boardID == DEVICE_ID_IOX3  ||  _boardID == DEVICE_ID_KONA5_8K_MV_TX)
            totalFrames -= 6;   //  Lop off 48MB for HDMI MultiViewer
        return totalFrames;
    }
    return ::NTV2DeviceGetNumberFrameBuffers(_boardID); //  Handle non-stacked-audio devices
}

bool CNTV2Card::GetInstalledBitfileInfo (ULWord & outNumBytes, std::string & outDateStr, std::string & outTimeStr)
{
    outDateStr.clear ();
    outTimeStr.clear ();
    outNumBytes = 0;

    if (!_boardOpened)
        return false;   //  Bail if I'm not open

    BITFILE_INFO_STRUCT     bitFileInfo;
    ::memset (&bitFileInfo, 0, sizeof (bitFileInfo));
    bitFileInfo.whichFPGA = eFPGAVideoProc;

    //  Call the OS specific method...
    if (!DriverGetBitFileInformation (bitFileInfo, NTV2_VideoProcBitFile))
        return false;

    //  Fill in our OS independent data structure...
    outDateStr = reinterpret_cast <char *> (&bitFileInfo.dateStr [0]);
    outTimeStr = reinterpret_cast <char *> (&bitFileInfo.timeStr [0]);
    outNumBytes = bitFileInfo.numBytes;
    return true;
}

string CNTV2Card::GetBitfileInfoString (const BITFILE_INFO_STRUCT & inBitFileInfo)
{
    ostringstream oss;
    // format like: "date time name"
    oss << inBitFileInfo.dateStr << " " << inBitFileInfo.timeStr << " ";
    if (NTV2BitfileType(inBitFileInfo.bitFileType) == NTV2_BITFILE_IO4KPLUS_MAIN  &&  IsSupported(kDeviceHasMicrophoneInput))
        oss << "DNxIV";
    else
        oss << ::NTV2BitfileTypeToString(NTV2BitfileType(inBitFileInfo.bitFileType), true);
    return oss.str();
}

bool CNTV2Card::IsFailSafeBitfileLoaded (bool & outIsSafeBoot)
{
    outIsSafeBoot = false;
    if (!IsSupported(kDeviceCanReportFailSafeLoaded))
        return false;
    return CNTV2DriverInterface::ReadRegister(kRegCPLDVersion, outIsSafeBoot, BIT(4), 4);
}


bool CNTV2Card::CanWarmBootFPGA (bool & outCanWarmBoot)
{
    outCanWarmBoot = false; //  Definitely can't
    if (!IsSupported(kDeviceCanDoWarmBootFPGA))
        return false;

    ULWord  version(0);
    if (!ReadRegister(kRegCPLDVersion, version, BIT(0)|BIT(1)))
        return false;   //  Fail
    if (version != 3)
        outCanWarmBoot = true;  //  Definitely can
    return true;
}


NTV2BreakoutType CNTV2Card::GetBreakoutHardware (void)
{
    NTV2BreakoutType    result      (NTV2_BreakoutNone);
    ULWord              audioCtlReg (0);    //  The Audio Control Register tells us what's connected

    if (IsOpen ()  &&  ReadRegister (kRegAud1Control, audioCtlReg))
    {
        const bool  bPhonyKBox  (false);    //  For debugging

        switch (_boardID)
        {
            case DEVICE_ID_KONA3G:
            case DEVICE_ID_KONA3GQUAD:
            case DEVICE_ID_IO4K:
            case DEVICE_ID_KONA4:
            case DEVICE_ID_KONA4UFC:
            case DEVICE_ID_KONA5:
            case DEVICE_ID_KONA5_8KMK:
            case DEVICE_ID_KONA5_8K:
            case DEVICE_ID_KONA5_2X4K:
            case DEVICE_ID_KONA5_3DLUT:
            case DEVICE_ID_KONA5_OE1:
            case DEVICE_ID_KONA5_8K_MV_TX:
                //  Do we have a K3G-Box?
                if ((audioCtlReg & kK2RegMaskKBoxDetect) || bPhonyKBox)
                    result = NTV2_K3GBox;
                else
                    result = NTV2_BreakoutCableBNC;
                break;
            case DEVICE_ID_KONALHEPLUS:
                //  Do we have a KL-Box?
                if ((audioCtlReg & kK2RegMaskKBoxDetect) || bPhonyKBox)
                    result = NTV2_KLBox;
                else
                    result = NTV2_BreakoutCableXLR;     // no BNC breakout cable available
                break;
            case DEVICE_ID_KONALHI:
                //  Do we have a KLHi-Box?
                if ((audioCtlReg & kK2RegMaskKBoxDetect) || bPhonyKBox)
                    result = NTV2_KLHiBox;
                else
                    result = NTV2_BreakoutCableXLR;     // no BNC breakout cable available
                break;
            case DEVICE_ID_KONAX:
            case DEVICE_ID_KONAX_4CH:
                // Do we have a BOB?
                if (IsSupported(kDeviceHasBreakoutBoard))
                    result = NTV2_BreakoutBoard;
                break;
            default:
                break;
        }
    }
    return result;
}

bool CNTV2Card::GetLPExternalConfigurationURLString (string & outURLString)
{
    if (!IsSupported(kDeviceHasLPProductCode))
        return false;
    uint32_t portIP(0);
    int ipOctet(0);
    ostringstream tempString;
    ReadRegister(kRegLPRJ45IP, portIP);
    if (portIP == 0)
        return false;
    
    outURLString.clear();
    tempString << "http://";
    ipOctet = (portIP & 0xFF000000) >> 24;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x00FF0000) >> 16;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x0000FF00) >> 8;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x000000FF);
    tempString << ipOctet;
    
    outURLString = tempString.str();
    return true;
}

bool CNTV2Card::GetLPTunnelConfigurationURLString (string & outURLString)
{
    if (!IsSupported(kDeviceHasLPProductCode))
        return false;
    uint32_t portIP(0);
    int ipOctet(0);
    ostringstream tempString;
    ReadRegister(kRegLPTunnelIP, portIP);
    if (portIP == 0)
        return false;
    
    outURLString.clear();
    tempString << "http://";
    ipOctet = (portIP & 0xFF000000) >> 24;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x00FF0000) >> 16;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x0000FF00) >> 8;
    tempString << ipOctet << ".";
    ipOctet = (portIP & 0x000000FF);
    tempString << ipOctet;
    
    outURLString = tempString.str();
    return true;
}

int CNTV2Card::GetSFPConfigurationURLStrings(std::vector<std::string> & OutSFPURLStrings)
{
    const ULWord numSFPs (GetNumSupported(kDeviceGetNum25GSFPs));
    if (!IsSupported(kDeviceHasLPProductCode) || numSFPs == 0)
        return 0;

    for (ULWord ndx(0);  ndx < numSFPs;  ndx++)
    {
        uint32_t portIP(0);
        int ipOctet(0);
        ostringstream tempString;
        ReadRegister(kRegLPSFP1IP + ndx, portIP);
        if (portIP == 0)
            return false;
        
        tempString << "http://";
        ipOctet = (portIP & 0xFF000000) >> 24;
        tempString << ipOctet << ".";
        ipOctet = (portIP & 0x00FF0000) >> 16;
        tempString << ipOctet << ".";
        ipOctet = (portIP & 0x0000FF00) >> 8;
        tempString << ipOctet << ".";
        ipOctet = (portIP & 0x000000FF);
        tempString << ipOctet;
        
        OutSFPURLStrings.push_back(tempString.str());
    }
    return int(OutSFPURLStrings.size());
}

#if !defined(NTV2_DEPRECATE_16_3)
    bool CNTV2Card::DeviceCanDoFormat (NTV2FrameRate        inFrameRate,
                                        NTV2FrameGeometry   inFrameGeometry, 
                                        NTV2Standard        inStandard)
    {
        return ::NTV2DeviceCanDoFormat (GetDeviceID(), inFrameRate, inFrameGeometry, inStandard);
    }

    ULWord  CNTV2Card::DeviceGetFrameBufferSize (void)
    {
        return ::NTV2DeviceGetFrameBufferSize (GetDeviceID());      //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetAudioFrameBuffer (void)
    {
        return ::NTV2DeviceGetAudioFrameBuffer (GetDeviceID());     //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetAudioFrameBuffer2 (void)
    {
        return ::NTV2DeviceGetAudioFrameBuffer2 (GetDeviceID());        //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetFrameBufferSize (const NTV2FrameGeometry inFrameGeometry, const NTV2FrameBufferFormat inFBFormat)
    {
        return ::NTV2DeviceGetFrameBufferSize (GetDeviceID(), inFrameGeometry, inFBFormat); //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetNumberFrameBuffers (const NTV2FrameGeometry inFrameGeometry, const NTV2FrameBufferFormat inFBFormat)
    {
        return ::NTV2DeviceGetNumberFrameBuffers (GetDeviceID(), inFrameGeometry, inFBFormat);  //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetAudioFrameBuffer (const NTV2FrameGeometry inFrameGeometry, const NTV2FrameBufferFormat inFBFormat)
    {
        return ::NTV2DeviceGetAudioFrameBuffer (GetDeviceID(), inFrameGeometry, inFBFormat);    //  Revisit for 2MB granularity
    }

    ULWord  CNTV2Card::DeviceGetAudioFrameBuffer2 (const NTV2FrameGeometry inFrameGeometry, const NTV2FrameBufferFormat inFBFormat)
    {
        return ::NTV2DeviceGetAudioFrameBuffer2 (GetDeviceID(), inFrameGeometry, inFBFormat);   //  Revisit for 2MB granularity
    }

    bool CNTV2Card::DeviceCanDoVideoFormat (const NTV2VideoFormat inVideoFormat)
    {   const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_VideoFormat));
        return itms.find(ULWord(inVideoFormat)) != itms.end();
    }

    bool CNTV2Card::DeviceCanDoFrameBufferFormat (const NTV2FrameBufferFormat inFBFormat)
    {   const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_PixelFormat));
        return itms.find(ULWord(inFBFormat)) != itms.end();
    }

    bool CNTV2Card::DeviceCanDoWidget (const NTV2WidgetID inWidgetID)
    {
        const ULWordSet wgtIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
        return wgtIDs.find(inWidgetID) != wgtIDs.end();
    }
    
    bool CNTV2Card::DeviceCanDoConversionMode (const NTV2ConversionMode inConversionMode)
    {   const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_ConversionMode));
        return itms.find(ULWord(inConversionMode)) != itms.end();
    }

    bool CNTV2Card::DeviceCanDoDSKMode (const NTV2DSKMode inDSKMode)
    {   const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_DSKMode));
        return itms.find(ULWord(inDSKMode)) != itms.end();
    }

    bool CNTV2Card::DeviceCanDoInputSource (const NTV2InputSource inInputSource)
    {   const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_InputSource));
        return itms.find(ULWord(inInputSource)) != itms.end();
    }
#endif  //  !defined(NTV2_DEPRECATE_16_3)


NTV2Buffer CNTV2Card::NULL_POINTER (AJA_NULL, 0);




bool DeviceCapabilities::CanDoWidget (const NTV2WidgetType inWgtType, const UWord index0)
{
    return CanDoWidget(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(inWgtType, NTV2Channel(index0)));
}


#define _TO_STR(_x_)        #_x_

AJALock DeviceCapabilities::sInitLock;
NTV2StringList DeviceCapabilities::sBoolParamIDStrs, DeviceCapabilities::sNumParamIDStrs, DeviceCapabilities::sEnumsIDStrs; //  STATIC

string DeviceCapabilities::BoolParamIDToString (const NTV2BoolParamID p)    //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sBoolParamIDStrs.empty())
    {
        sBoolParamIDStrs.reserve(size_t(kNTV2BoolParam_COUNT));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanChangeEmbeddedAudioClock));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanChangeFrameBufferSize));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDisableUFC));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo2KVideo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo3GLevelConversion));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoRGBLevelAConversion));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo425Mux));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo4KVideo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAESAudioIn));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAnalogAudio));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAnalogVideoIn));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAnalogVideoOut));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudio2Channels));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudio6Channels));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudio8Channels));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudio96K));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudioDelay));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoBreakoutBox));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoCapture));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoColorCorrection));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoCustomAnc));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoDSKOpacity));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoDualLink));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoDVCProHD));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoEnhancedCSC));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoFrameStore1Display));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoFreezeOutput));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIOutStereo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDV));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDVideo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoIsoConvert));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoLTC));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoLTCInOnRefPort));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoMSI));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoMultiFormat));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoPCMControl));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoPCMDetection));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoPIO));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoPlayback));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoProgrammableCSC));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoProgrammableRS422));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoProRes));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoQREZ));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoQuarterExpand));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoRateConvert));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoRGBPlusAlphaOut));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoRP188));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoSDVideo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoSDIErrorChecks));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoStackedAudio));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoStereoIn));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoStereoOut));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoThunderbolt));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoVideoProcessing));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanMeasureTemperature));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanReportFrameSize));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasBiDirectionalSDI));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasColorSpaceConverterOnChannel2));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasNWL));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasPCIeGen2));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasRetailSupport));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSDIRelays));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIFlash));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIFlashSerial));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIv2));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIv3));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIv4));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceIs64Bit));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceIsDirectAddressable));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceIsExternalToHost));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceIsLocalPhysical));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceIsSupported));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceNeedsRoutingSetup));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceSoftwareCanChangeFrameBufferSize));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanThermostat));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasHEVCM31));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasHEVCM30));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoVITC2));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIHDROut));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoJ2K));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo12gRouting));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo12GSDI));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo2110));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo8KVideo));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudio192K));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudioMixer));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIAuxCapture));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIAuxPlayback));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoFramePulseSelect));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIMultiView));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasMultiRasterWidget));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHFRRGB));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoIP));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoMultiLinkAudio));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoWarmBootFPGA));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanReportFailSafeLoaded));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanReportRunningFirmwareDate));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasAudioMonitorRCAJacks));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasBiDirectionalAnalogAudio));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasGenlockv2));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasGenlockv3));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasHeadphoneJack));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasLEDAudioMeters));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasRotaryEncoder));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasSPIv5));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasXilinxDMA));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasMicrophoneInput));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoBreakoutBoard));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasBreakoutBoard));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceAudioCanWaitForVBI));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasNTV4FrameStores));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasXptConnectROM));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudioInput));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAudioOutput));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoAESAudioOut));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasIDSwitch));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoHDMIQuadRasterConversion));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoCustomHancInsertion));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoStreamingDMA));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasPWMFanControl));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceROMHasBankSelect));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoVersalSysMon));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoGPIO));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasBracketLED));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDo25GIP));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanReportMixerDelay));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceHasLPProductCode));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoP2PTransmit));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoP2PReceive));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoFastBitfileSwitching));
        sBoolParamIDStrs.push_back(_TO_STR(kDeviceCanDoClockMonitor));
        NTV2_ASSERT(sBoolParamIDStrs.size() == size_t(kNTV2BoolParam_COUNT));
        for (size_t ndx(0);  ndx < sBoolParamIDStrs.size();  ndx++)
            sBoolParamIDStrs.at(ndx).erase(0, 7);   //  Lop off leading "kDevice"
    }   //  if never initialized
    return size_t(p) < sBoolParamIDStrs.size() ? sBoolParamIDStrs.at(size_t(p)) : "";
}   //  BoolParamIDToString

string DeviceCapabilities::NumParamIDToString (const NTV2NumericParamID p)  //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sNumParamIDStrs.empty())
    {
        sNumParamIDStrs.reserve(size_t(kNTV2NumericParam_COUNT));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetActiveMemorySize));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetDACVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetDownConverterDelay));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetHDMIVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetLUTVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetMaxAudioChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetMaxRegisterNumber));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetMaxTransferCount));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumDMAEngines));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumVideoChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetPingLED));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetUFCVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNum4kQuarterSizeConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAESAudioInputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAESAudioOutputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAnalogAudioInputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAnalogAudioOutputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAnalogVideoInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAnalogVideoOutputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumAudioSystems));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumCrossConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumCSCs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumDownConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumEmbeddedAudioInputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumEmbeddedAudioOutputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumFrameStores));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumFrameSyncs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumHDMIAudioInputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumHDMIAudioOutputChannels));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumHDMIVideoInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumHDMIVideoOutputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumInputConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumLUTs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumMixers));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumOutputConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumReferenceVideoInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumSerialPorts));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumUpConverters));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumVideoInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumVideoOutputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNum2022ChannelsSFP1));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNum2022ChannelsSFP2));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumLTCInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumLTCOutputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumMicInputs));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumLUTBanks));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetTotalNumAudioSystems));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumBufferedAudioSystems));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNumTSIMuxers));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetSPIFlashVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetGenlockVersion));
        sNumParamIDStrs.push_back(_TO_STR(kDeviceGetNum25GSFPs));
        NTV2_ASSERT(sNumParamIDStrs.size() == size_t(kNTV2NumericParam_COUNT));
        for (size_t ndx(0);  ndx < sNumParamIDStrs.size();  ndx++)
            sNumParamIDStrs.at(ndx).erase(0, 7);    //  Lop off leading "kDevice"
    }   //  if never initialized
    const size_t ndx (p >= kNTV2NumericParam_FIRST  &&  p < kNTV2NumericParam_LAST  ?  p - kNTV2NumericParam_FIRST  :  kDeviceGetNum_INVALID);
    return ndx < sNumParamIDStrs.size() ? sNumParamIDStrs.at(ndx) : "";
}   //  NumParamIDToString

string DeviceCapabilities::EnumsIDToString (const NTV2EnumsID p)    //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sEnumsIDStrs.empty())
    {
        sEnumsIDStrs.reserve(kNTV2EnumsID_COUNT);
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_DeviceID));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_Standard));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_PixelFormat));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_FrameGeometry));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_FrameRate));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_ScanGeometry));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_VideoFormat));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_Mode));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_InputSource));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_OutputDest));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_Channel));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_RefSource));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_AudioRate));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_AudioSource));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_WidgetID));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_ConversionMode));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_DSKMode));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_InputTCIndex));
        sEnumsIDStrs.push_back(_TO_STR(kNTV2EnumsID_OutputTCIndex));
        NTV2_ASSERT(sEnumsIDStrs.size() == size_t(kNTV2EnumsID_COUNT));
        for (size_t ndx(0);  ndx < sEnumsIDStrs.size();  ndx++)
            sEnumsIDStrs.at(ndx).erase(0, 13);  //  Lop off leading "kNTV2EnumsID_"
    }   //  if never initialized
    return size_t(p) < sEnumsIDStrs.size() ? sEnumsIDStrs.at(size_t(p)) : "";
}

#define InitStrToIDMap(_eid_,_t_,_max_,_fn_)    m.clear();                                              \
                                                for (n = 0;  n < _max_;  n++)                           \
                                                {                                                       \
                                                    if (!aja::lower(st = _fn_(_t_(n), false)).empty())  \
                                                        m[st] = n;                                      \
                                                    if (!aja::lower(st = _fn_(_t_(n), true)).empty())   \
                                                        m[st] = n;                                      \
                                                }                                                       \
                                                sStrToIDMaps.at(_eid_) = m;

DeviceCapabilities::GenericStrToIDMap   DeviceCapabilities::sStrBoolParamIDMap, DeviceCapabilities::sStrNumParamIDMap, DeviceCapabilities::sStrEnumsIDMap;  //  STATIC
DeviceCapabilities::GenericStrToIDMaps  DeviceCapabilities::sStrToIDMaps;   //  STATIC

void DeviceCapabilities::Init (void)    //  STATIC
{   //  One stop shop for initialization
    AJAAutoLock tmp(&sInitLock);
    GenericStrToIDMapCI it;
    if (sStrBoolParamIDMap.empty())
    {
        BoolParamIDToString(kDeviceCanChangeEmbeddedAudioClock);    //  Ensure sBoolParamIDStrs initialized
        for (size_t ndx(0);  ndx < sBoolParamIDStrs.size();  ndx++)
        {
            string st(sBoolParamIDStrs.at(ndx));
            aja::lower(st);
            const NTV2BoolParamID id (NTV2BoolParamID(kNTV2BoolParam_FIRST + ndx));
            it = sStrBoolParamIDMap.find(st);
            if (it == sStrBoolParamIDMap.end())
                sStrBoolParamIDMap[st] = id;
            st = "device" + st;
            it = sStrBoolParamIDMap.find(st);
            if (it == sStrBoolParamIDMap.end())
                sStrBoolParamIDMap[st] = id;
            st = "k" + st;
            it = sStrBoolParamIDMap.find(st);
            if (it == sStrBoolParamIDMap.end())
                sStrBoolParamIDMap[st] = id;
        }
        sStrBoolParamIDMap["kdevicecandocustomaux"] = kDeviceCanDoHDMIAuxCapture;
        sStrBoolParamIDMap["devicecandocustomaux"]  = kDeviceCanDoHDMIAuxCapture;
        sStrBoolParamIDMap["candocustomaux"]        = kDeviceCanDoHDMIAuxCapture;
        sStrBoolParamIDMap["kdevicecandoidswitch"]  = kDeviceHasIDSwitch;
        sStrBoolParamIDMap["devicecandoidswitch"]   = kDeviceHasIDSwitch;
        sStrBoolParamIDMap["candoidswitch"]         = kDeviceHasIDSwitch;
    }
    if (sStrNumParamIDMap.empty())
    {
        NumParamIDToString(kDeviceGetActiveMemorySize); //  Ensure sNumParamIDStrs initialized
        for (size_t ndx(0);  ndx < sNumParamIDStrs.size();  ndx++)
        {
            string st(sNumParamIDStrs.at(ndx));
            aja::lower(st);
            const NTV2NumericParamID id (NTV2NumericParamID(kNTV2NumericParam_FIRST + ndx));
            it = sStrNumParamIDMap.find(st);
            if (it == sStrNumParamIDMap.end())
                sStrNumParamIDMap[st] = id;
            st = "device" + st;
            it = sStrNumParamIDMap.find(st);
            if (it == sStrNumParamIDMap.end())
                sStrNumParamIDMap[st] = id;
            st = "k" + st;
            it = sStrNumParamIDMap.find(st);
            if (it == sStrNumParamIDMap.end())
                sStrNumParamIDMap[st] = id;
        }
    }
    if (sStrEnumsIDMap.empty())
    {
        EnumsIDToString(kNTV2EnumsID_Standard); //  Ensure sEnumsIDStrs initialized
        for (size_t ndx(0);  ndx < sEnumsIDStrs.size();  ndx++)
        {
            string st(sEnumsIDStrs.at(ndx));
            aja::lower(st);
            const NTV2EnumsID id (NTV2EnumsID(kNTV2EnumsID_FIRST + ndx));
            it = sStrEnumsIDMap.find(st);
            if (it == sStrEnumsIDMap.end())
                sStrEnumsIDMap[st] = id;
            st = "enumsid_" + st;
            it = sStrEnumsIDMap.find(st);
            if (it == sStrEnumsIDMap.end())
                sStrEnumsIDMap[st] = id;
            st = "ntv2" + st;
            it = sStrEnumsIDMap.find(st);
            if (it == sStrEnumsIDMap.end())
                sStrEnumsIDMap[st] = id;
            st = "k" + st;
            it = sStrEnumsIDMap.find(st);
            if (it == sStrEnumsIDMap.end())
                sStrEnumsIDMap[st] = id;
        }
    }
    if (sStrToIDMaps.empty())
    {
        string st;
        ULWord n(0);
        while (sStrToIDMaps.size() < kNTV2EnumsID_LAST)
            sStrToIDMaps.push_back(GenericStrToIDMap());
        GenericStrToIDMap m;
//      InitStrToIDMap(kNTV2EnumsID_Device, NTV2DeviceID, ---n/a---, NTV2DeviceIDToString);
        InitStrToIDMap(kNTV2EnumsID_Standard, NTV2Standard, NTV2_NUM_STANDARDS, NTV2StandardToString);
        m["standards"] = kNTV2EnumsID_Standard;
        InitStrToIDMap(kNTV2EnumsID_PixelFormat, NTV2PixelFormat, NTV2_FBF_LAST, NTV2FrameBufferFormatToString);
        m["pixelformats"] = kNTV2EnumsID_PixelFormat;
        InitStrToIDMap(kNTV2EnumsID_FrameGeometry, NTV2FrameGeometry, NTV2_FG_LAST, NTV2FrameGeometryToString);
        InitStrToIDMap(kNTV2EnumsID_FrameRate, NTV2FrameRate, NTV2_FRAMERATE_LAST, NTV2FrameRateToString);
        InitStrToIDMap(kNTV2EnumsID_VideoFormat, NTV2VideoFormat, NTV2_MAX_NUM_VIDEO_FORMATS, NTV2VideoFormatToString);
        InitStrToIDMap(kNTV2EnumsID_Mode, NTV2Mode, NTV2_MODE_INVALID, NTV2ModeToString);
        InitStrToIDMap(kNTV2EnumsID_InputSource, NTV2InputSource, NTV2_NUM_INPUTSOURCES, NTV2InputSourceToString);
        InitStrToIDMap(kNTV2EnumsID_OutputDest, NTV2OutputDest, NTV2_NUM_OUTPUTDESTINATIONS, NTV2OutputDestinationToString);
        m["outputdestination"] = kNTV2EnumsID_OutputDest;
        m["outputdestinations"] = kNTV2EnumsID_OutputDest;
        InitStrToIDMap(kNTV2EnumsID_Channel, NTV2Channel, NTV2_MAX_NUM_CHANNELS, NTV2ChannelToString);
        InitStrToIDMap(kNTV2EnumsID_RefSource, NTV2RefSource, NTV2_NUM_REFERENCE_INPUTS, NTV2ReferenceSourceToString);
        InitStrToIDMap(kNTV2EnumsID_AudioRate, NTV2AudioRate, NTV2_MAX_NUM_AudioRates, NTV2AudioRateToString);
        InitStrToIDMap(kNTV2EnumsID_AudioSource, NTV2AudioSource, NTV2_MAX_NUM_AudioSources, NTV2AudioSourceToString);
        InitStrToIDMap(kNTV2EnumsID_WidgetID, NTV2WidgetID, NTV2_WgtModuleTypeCount, NTV2WidgetIDToString);
        m["widgetids"] = kNTV2EnumsID_WidgetID;
//      InitStrToIDMap(kNTV2EnumsID_ConversionMode, NTV2ConversionMode, NTV2_NUM_CONVERSIONMODES, NTV2ConversionModeToString);
//      InitStrToIDMap(kNTV2EnumsID_DSKMode, NTV2DSKMode, NTV2_DSKModeMax, NTV2DSKModeToString);
        InitStrToIDMap(kNTV2EnumsID_InputTCIndex, NTV2TCIndex, NTV2_MAX_NUM_TIMECODE_INDEXES, NTV2TCIndexToString);
        InitStrToIDMap(kNTV2EnumsID_OutputTCIndex, NTV2TCIndex, NTV2_MAX_NUM_TIMECODE_INDEXES, NTV2TCIndexToString);
    }   //  if uninitialized
}   //  Init

NTV2BoolParamID DeviceCapabilities::StringToBoolParamID (string s)  //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sStrBoolParamIDMap.empty())
        Init();
    aja::lower(aja::strip(s));
    GenericStrToIDMapCI it (sStrBoolParamIDMap.find(s));
    return it != sStrBoolParamIDMap.end()  ?  NTV2BoolParamID(it->second)  :  kDeviceCanDo_INVALID;
}

NTV2NumericParamID DeviceCapabilities::StringToNumParamID (string s)    //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sStrNumParamIDMap.empty())
        Init();
    aja::lower(aja::strip(s));
    GenericStrToIDMapCI it (sStrNumParamIDMap.find(s));
    return it != sStrNumParamIDMap.end()  ?  NTV2NumericParamID(it->second)  :  kDeviceGetNum_INVALID;
}

NTV2EnumsID DeviceCapabilities::StringToEnumsParamID (string s) //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sStrEnumsIDMap.empty())
        Init();
    aja::lower(aja::strip(s));
    GenericStrToIDMapCI it (sStrEnumsIDMap.find(s));
    return it != sStrEnumsIDMap.end()  ?  NTV2EnumsID(it->second)  :  kNTV2EnumsID_INVALID;
}

bool DeviceCapabilities::StringToSupportedEnumsIDValue (ULWord & outVal, const NTV2EnumsID id, string s)    //  STATIC
{
    AJAAutoLock tmp(&sInitLock);
    if (sStrToIDMaps.empty())
        Init();
    if (id >= sStrToIDMaps.size())
        return false;   //  No such map or bad EnumsID
    GenericStrToIDMap & m (sStrToIDMaps.at(id));
    if (m.empty())
        return false;   //  NTV2EnumsID unsupported  (e.g. Device, ConversionMode, DSKMode, etc.)
    GenericStrToIDMapCI iter(m.find(aja::strip(aja::lower(s))));
    if (iter == m.end())
        return false;
    outVal = iter->second;
    return true;
}   //  StringToSupportedEnumsIDValue




bool SDRAMAuditor::AssessDevice (CNTV2Card & inDevice, const bool inMarkStoppedAudioBuffersFree)
{
    mFrameTags.clear();
    mDeviceID = DEVICE_ID_INVALID;
    mNumFrames = 0;
    mIntrinsicSize = 0;
    if (!inDevice.IsOpen())
        return false;

    mDeviceID = inDevice.GetDeviceID();
    const ULWord totalBytes(::NTV2DeviceGetActiveMemorySize(mDeviceID));
    mNumFrames = UWord(totalBytes / m8MB);
    if (totalBytes % m8MB)
        {mNumFrames++;  cerr << DEC(totalBytes % m8MB) << " leftover/spare bytes -- last frame is partial frame" << endl;}
    for (UWord frm(0);  frm < mNumFrames;  frm++)
        mFrameTags.insert(FrameTag(frm, NTV2StringSet()));

    return TagAudioBuffers(inDevice, inMarkStoppedAudioBuffersFree) && TagVideoFrames(inDevice);
}

ostream & SDRAMAuditor::RawDump (ostream & oss) const
{
    for (FrameTagsConstIter it(mFrameTags.begin());  it != mFrameTags.end();  ++it)
    {
        const NTV2StringSet & tags(it->second);
        oss << DEC0N(it->first,3) << ": " << aja::join(tags, ", ") << endl;
    }
    return oss;
}

ULWordSet SDRAMAuditor::CoalesceRegions (const ULWordSequence & inRgn1, const ULWordSequence & inRgn2, const ULWordSequence & inRgn3)
{
    ULWordSet result;   //  Coalesce all regions into this one sorted set
    for (size_t ndx(0);  ndx < inRgn1.size();  ndx++)
        if (result.find(inRgn1.at(ndx)) == result.end())
            result.insert(inRgn1.at(ndx));
    for (size_t ndx(0);  ndx < inRgn2.size();  ndx++)
        if (result.find(inRgn2.at(ndx)) == result.end())
            result.insert(inRgn2.at(ndx));
    for (size_t ndx(0);  ndx < inRgn3.size();  ndx++)
        if (result.find(inRgn3.at(ndx)) == result.end())
            result.insert(inRgn3.at(ndx));
    return result;
}

ostream & SDRAMAuditor::DumpBlocks (ostream & oss) const
{
    ULWordSequence badBlks, freeBlks, goodBlks;
    GetRegions (freeBlks, goodBlks, badBlks);
    ULWordSet rgns (CoalesceRegions(freeBlks, goodBlks, badBlks));  //  Coalesce all regions into this one sorted set

    for (ULWordSetConstIter it(rgns.begin());  it != rgns.end();  ++it)
    {
        const ULWord rgnInfo(*it);
        const UWord startBlk(rgnInfo >> 16), numBlks(UWord(rgnInfo & 0x0000FFFF));
        NTV2StringSet tags;
        GetTagsForFrameIndex (startBlk, tags);
        if (numBlks > 1)
            oss << "Frms " << DEC0N(startBlk,3) << "-" << DEC0N(startBlk+numBlks-1,3) << " : ";
        else
            oss << "Frm  " << DEC0N(startBlk,3) << "     : ";
        if (tags.empty())
            oss << "{free}";
        else
            oss << aja::join(tags, ", ");
        oss << endl;
    }
    return oss;
}

bool SDRAMAuditor::GetRegions (ULWordSequence & outFree, ULWordSequence & outUsed, ULWordSequence & outBad) const
{
    outFree.clear();  outUsed.clear();  outBad.clear();
    FrameTagsConstIter it(mFrameTags.begin());
    if (it == mFrameTags.end())
        return true;
    UWord frmStart(it->first), lastFrm(frmStart);
    NTV2StringSet runTags(it->second);
    while (++it != mFrameTags.end())
    {
        const NTV2StringSet & tags(it->second);
        if (tags != runTags)
        {   //  End of current run, start of new run
            if (runTags.empty())
            {
                if (frmStart != lastFrm)
                    outFree.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
                else
                    outFree.push_back((ULWord(frmStart) << 16) | ULWord(1));
            }
            else if (runTags.size() > 1)
            {
                if (frmStart != lastFrm)
                    outBad.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
                else
                    outBad.push_back((ULWord(frmStart) << 16) | ULWord(1));
            }
            else
            {
                if (frmStart != lastFrm)
                    outUsed.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
                else
                    outUsed.push_back((ULWord(frmStart) << 16) | ULWord(1));
            }
            frmStart = lastFrm = it->first;
            runTags = tags;
        }
        else
            lastFrm = it->first;    //  Continue current run
    }
    if (runTags.empty())
    {
        if (frmStart != lastFrm)
            outFree.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
        else
            outFree.push_back((ULWord(frmStart) << 16) | ULWord(1));
    }
    else if (runTags.size() > 1)
    {
        if (frmStart != lastFrm)
            outBad.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
        else
            outBad.push_back((ULWord(frmStart) << 16) | ULWord(1));
    }
    else
    {
        if (frmStart != lastFrm)
            outUsed.push_back((ULWord(frmStart) << 16) | ULWord(lastFrm-frmStart+1));
        else
            outUsed.push_back((ULWord(frmStart) << 16) | ULWord(1));
    }
    return true;
}

bool SDRAMAuditor::GetTagsForFrameIndex (const UWord inIndex, NTV2StringSet & outTags) const
{
    outTags.clear();
    FrameTagsConstIter it(mFrameTags.find(inIndex));
    if (it == mFrameTags.end())
        return false;
    outTags = it->second;
    return true;
}

size_t SDRAMAuditor::GetTagCount (const UWord inIndex) const
{
    FrameTagsConstIter it(mFrameTags.find(inIndex));
    if (it == mFrameTags.end())
        return 0;
    return it->second.size();
}

bool SDRAMAuditor::TranslateRegions (ULWordSequence & outDestRgns, const ULWordSequence & inSrcRgns, const bool inIsQuad, const bool inIsQuadQuad) const
{
    outDestRgns.clear();
    if (inIsQuad && inIsQuadQuad)
        return false;   //  Can't be both
    if (inSrcRgns.empty())
        return true;    //  Empty list, not an error
    const UWord _8MB_frames_per_dest_frame(UWord(GetIntrinsicFrameByteCount() / m8MB) * (inIsQuad?4:1) * (inIsQuadQuad?16:1));  //  Should result in 1/4/16 or 2/8/32
    if (!_8MB_frames_per_dest_frame)
        return false;   //  Ordinarily won't happen, but possible with "ntv2:" (fake/software) "devices" having small SDRAM complement
    if (_8MB_frames_per_dest_frame == 1)
        {outDestRgns = inSrcRgns;   return true;}   //  Same

    //  For each region...
    for (size_t ndx(0);  ndx < inSrcRgns.size();  ndx++)
    {   const ULWord val(inSrcRgns.at(ndx));
        ULWord startBlkOffset(val >> 16), lengthBlks(val & 0x0000FFFF);     //  <== These are in 8MB block units
        startBlkOffset = startBlkOffset / _8MB_frames_per_dest_frame  +  (startBlkOffset % _8MB_frames_per_dest_frame ? 1 : 0);
        lengthBlks = lengthBlks / _8MB_frames_per_dest_frame;
        outDestRgns.push_back((startBlkOffset << 16) | lengthBlks);
    }
    return true;
}

bool SDRAMAuditor::TagAudioBuffers (CNTV2Card & inDevice, const bool inMarkStoppedAudioBuffersFree)
{
    ULWord addr(0);
    bool isReading(false), isWriting(false);
    const UWord numAudSystems(UWord(inDevice.GetNumSupported(kDeviceGetNumBufferedAudioSystems)));
    for (NTV2AudioSystem audSys(NTV2_AUDIOSYSTEM_1);  audSys < NTV2AudioSystem(numAudSystems);  audSys = NTV2AudioSystem(audSys+1))
        if (inDevice.GetAudioMemoryOffset (0,  addr,  audSys))
        {   ostringstream tag;
            tag << "Aud" << DEC(audSys+1);
            if (inDevice.IsAudioOutputRunning(audSys, isReading)  &&  isReading)
                tag << " Read";
            if (inDevice.IsAudioInputRunning(audSys, isWriting)  &&  isWriting)
                tag << " Write";
            TagMemoryBlock(addr, m8MB, inMarkStoppedAudioBuffersFree && !isReading && !isWriting ? string() : tag.str());
        }
    return true;
}

bool SDRAMAuditor::TagVideoFrames (CNTV2Card & inDevice)
{
    const UWord numChannels (UWord(inDevice.GetNumSupported(kDeviceGetNumVideoChannels)) + (inDevice.HasMultiRasterWidget() ? 1 : 0));
    NTV2ChannelSet skipChannels;
    for (NTV2Channel chan(NTV2_CHANNEL1);  chan < NTV2Channel(numChannels);  chan = NTV2Channel(chan+1))
    {
        AUTOCIRCULATE_STATUS acStatus;
        bool isEnabled(false), isMultiFormat(false), isQuad(false), isQuadQuad(false), isSquares(false), isTSI(false);
        ostringstream tag;
        uint64_t addr(0), len(0);
        if (skipChannels.find(chan) != skipChannels.end())
            continue;   //  Skip this channel/framestore
        if (inDevice.AutoCirculateGetStatus (chan, acStatus)  &&  !acStatus.IsStopped())
        {
            uint64_t tmp(0);
            inDevice.GetDeviceFrameInfo(acStatus.GetStartFrame(), chan, mIntrinsicSize, isMultiFormat, isQuad, isQuadQuad, isSquares, isTSI, addr, tmp);
            inDevice.GetDeviceFrameInfo(acStatus.GetEndFrame(), chan, tmp, len);
            tag << "AC" << DEC(chan+1) << (acStatus.IsInput() ? " Write" : " Read");
            TagMemoryBlock(addr, tmp + len - addr, tag.str());
        }   //  if GetStatus succeeded
        else if (inDevice.IsChannelEnabled(chan, isEnabled)  &&  isEnabled)
        {
            NTV2Mode mode(NTV2_MODE_INVALID);
            inDevice.GetMode(chan, mode);
            ULWord frameNum(0);
            if (NTV2_IS_INPUT_MODE(mode))
                inDevice.GetInputFrame(chan, frameNum);
            else
                inDevice.GetOutputFrame(chan, frameNum);
            inDevice.GetDeviceFrameInfo (UWord(frameNum),  chan,  mIntrinsicSize, isMultiFormat, isQuad, isQuadQuad, isSquares, isTSI, addr,  len);
            if (inDevice.IsMultiRasterWidgetChannel(chan))
                tag << "MR" << DEC(chan+1); //  MultiRaster Viewer
            else
                tag << "Ch" << DEC(chan+1);
            tag << (NTV2_IS_INPUT_MODE(mode) ? " Write" : " Read");
            TagMemoryBlock(addr, len, tag.str());
        }
        if (isSquares && chan == NTV2_CHANNEL1)
            {skipChannels.insert(NTV2_CHANNEL2); skipChannels.insert(NTV2_CHANNEL3); skipChannels.insert(NTV2_CHANNEL4);}
        else if (isSquares && chan == NTV2_CHANNEL5)
            {skipChannels.insert(NTV2_CHANNEL6); skipChannels.insert(NTV2_CHANNEL7); skipChannels.insert(NTV2_CHANNEL8);}
        else if (isQuad  &&  !isQuadQuad  &&  isTSI)
        {
            if (chan == NTV2_CHANNEL1)
                skipChannels.insert(NTV2_CHANNEL2);
            else if (chan == NTV2_CHANNEL3)
                skipChannels.insert(NTV2_CHANNEL4);
            else if (chan == NTV2_CHANNEL5)
                skipChannels.insert(NTV2_CHANNEL6);
            else if (chan == NTV2_CHANNEL7)
                skipChannels.insert(NTV2_CHANNEL8);
        }
    }   //  for each device channel
    if (!mIntrinsicSize)
    {
        NTV2Framesize frmsz(NTV2_FRAMESIZE_8MB);
        inDevice.GetFrameBufferSize(NTV2_CHANNEL1, frmsz);
        mIntrinsicSize = ::NTV2FramesizeToByteCount(frmsz);
    }
    return true;
}

bool SDRAMAuditor::TagMemoryBlock (const ULWord inStartAddr, const ULWord inByteLength, const string & inTag)
{
    if (inStartAddr % m8MB)
        return false;
    if (inByteLength % m8MB)
        return false;
    if (inTag.empty())
        return false;
    const UWord startFrm(UWord(inStartAddr / m8MB)),  frmCnt(UWord(inByteLength / m8MB));
    for (UWord frm(0);  frm < frmCnt;  frm++)
    {
        UWord frameNum(startFrm + frm);
        NTV2StringSet & tags(mFrameTags[frameNum]);
        if (tags.find(inTag) == tags.end())
        {
            tags.insert(inTag);
            if (frameNum >= mNumFrames)
                tags.insert("Invalid");
        }
    }
    return true;
}