AJA NTV2 SDK  18.0.0.2122
NTV2 SDK 18.0.0.2122
ntv2driverinterface.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: MIT */
8 #include "ajatypes.h"
9 #include "ntv2enums.h"
10 #include "ntv2debug.h"
11 #include "ntv2driverinterface.h"
12 #include "ntv2devicefeatures.h"
13 #include "ntv2nubaccess.h"
14 #include "ntv2bitfile.h"
15 #include "ntv2registersmb.h" // for SAREK_REGS
16 #include "ntv2spiinterface.h"
17 #include "ntv2utils.h"
18 #include "ntv2version.h"
19 #include "ntv2devicescanner.h" // for IsHexDigit, IsAlphaNumeric, etc.
20 #include "ajabase/system/debug.h"
21 #include "ajabase/system/atomic.h"
22 #include "ajabase/system/systemtime.h"
23 #include "ajabase/system/process.h"
24 #include "ajabase/common/common.h" // aja::join
25 #include <string.h>
26 #include <assert.h>
27 #include <iostream>
28 #include <sstream>
29 #include <algorithm>
30 #include <map>
31 
32 using namespace std;
33 
34 #define INSTP(_p_) HEX0N(uint64_t(_p_),16)
35 #define DIFAIL(__x__) AJA_sERROR (AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
36 #define DIWARN(__x__) AJA_sWARNING(AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
37 #define DINOTE(__x__) AJA_sNOTICE (AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
38 #define DIINFO(__x__) AJA_sINFO (AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
39 #define DIDBG(__x__) AJA_sDEBUG (AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
40 
41 // Stats
42 static uint32_t gConstructCount(0); // Number of constructor calls made
43 static uint32_t gDestructCount(0); // Number of destructor calls made
44 static uint32_t gOpenCount(0); // Number of successful Open calls made
45 static uint32_t gCloseCount(0); // Number of Close calls made
46 //#define _DEBUGSTATS_ // Define this to log above construct/destruct & open/close tallies
47 #if defined(_DEBUGSTATS_)
48  #define DIDBGX(__x__) AJA_sDEBUG (AJA_DebugUnit_DriverInterface, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
49 #else
50  #define DIDBGX(__x__)
51 #endif
52 
54 
55 NTV2StringList CNTV2DriverInterface::GetLegalSchemeNames (void)
56 {
57  NTV2StringList result;
58  result.push_back("ntv2nub"); result.push_back("ntv2"); result.push_back("ntv2local");
59  return result;
60 }
61 
62 static bool gSharedMode(false);
63 void CNTV2DriverInterface::SetShareMode (const bool inSharedMode) {gSharedMode = inSharedMode;}
64 bool CNTV2DriverInterface::GetShareMode (void) {return gSharedMode;}
65 static bool gOverlappedMode(false);
66 void CNTV2DriverInterface::SetOverlappedMode (const bool inOverlapMode) {gOverlappedMode = inOverlapMode;}
67 bool CNTV2DriverInterface::GetOverlappedMode (void) {return gOverlappedMode;}
68 
69 
71 
72 CNTV2DriverInterface::CNTV2DriverInterface ()
73  : _boardNumber (0)
74  ,_boardID (DEVICE_ID_NOTFOUND)
75  ,_boardOpened (false)
76 #if defined(NTV2_WRITEREG_PROFILING)
77  ,mRecordRegWrites (false)
78  ,mSkipRegWrites (false)
79 #endif
80  ,_programStatus (0)
81  ,_pRPCAPI (AJA_NULL)
82  ,mInterruptEventHandles ()
83  ,mEventCounts ()
84 #if defined(NTV2_WRITEREG_PROFILING)
85  ,mRegWrites ()
86  ,mRegWritesLock ()
87 #endif // NTV2_WRITEREG_PROFILING
88 #if !defined(NTV2_DEPRECATE_16_0)
89  ,_pFrameBaseAddress (AJA_NULL)
90  ,_pRegisterBaseAddress (AJA_NULL)
91  ,_pRegisterBaseAddressLength (0)
92  ,_pXena2FlashBaseAddress (AJA_NULL)
93  ,_pCh1FrameBaseAddress (AJA_NULL)
94  ,_pCh2FrameBaseAddress (AJA_NULL)
95 #endif // !defined(NTV2_DEPRECATE_16_0)
96 #if !defined(NTV2_DEPRECATE_17_2)
97  ,_ulNumFrameBuffers (0)
98  ,_ulFrameBufferSize (0)
99 #endif
100 #if !defined(NTV2_DEPRECATE_16_0)
101  ,_pciSlot (0) // DEPRECATE!
102 #endif // !defined(NTV2_DEPRECATE_16_0)
103 {
104  mInterruptEventHandles.reserve(eNumInterruptTypes);
105  while (mInterruptEventHandles.size() < eNumInterruptTypes)
106  mInterruptEventHandles.push_back(AJA_NULL);
107 
108  mEventCounts.reserve(eNumInterruptTypes);
109  while (mEventCounts.size() < eNumInterruptTypes)
110  mEventCounts.push_back(0);
111  AJAAtomic::Increment(&gConstructCount);
112  DIDBGX(DEC(gConstructCount) << " constructed, " << DEC(gDestructCount) << " destroyed");
113 } // constructor
114 
115 
116 CNTV2DriverInterface::~CNTV2DriverInterface ()
117 {
118  AJAAtomic::Increment(&gDestructCount);
119  if (_pRPCAPI)
120  delete _pRPCAPI;
121  _pRPCAPI = AJA_NULL;
122  DIDBGX(DEC(gConstructCount) << " constructed, " << DEC(gDestructCount) << " destroyed");
123 } // destructor
124 
125 CNTV2DriverInterface & CNTV2DriverInterface::operator = (const CNTV2DriverInterface & inRHS)
126 { (void) inRHS; NTV2_ASSERT(false && "Not assignable"); return *this;} // operator =
127 
128 CNTV2DriverInterface::CNTV2DriverInterface (const CNTV2DriverInterface & inObjToCopy)
129 { (void) inObjToCopy; NTV2_ASSERT(false && "Not copyable");} // copy constructor
130 
131 
132 // Open local physical device (via ajantv2 driver)
133 bool CNTV2DriverInterface::Open (const UWord inDeviceIndex)
134 {
135  if (IsOpen() && inDeviceIndex == GetIndexNumber())
136  return true; // Same local device requested, already open
137  Close();
138  if (inDeviceIndex >= MaxNumDevices())
139  {DIFAIL("Requested device index '" << DEC(inDeviceIndex) << "' at/past limit of '" << DEC(MaxNumDevices()) << "'"); return false;}
140  if (!OpenLocalPhysical(inDeviceIndex))
141  {
142  // Check for virtual device...
143  static ULWord sRecursionCheck(0), RECURSION_LIMIT(32);
144  NTV2DeviceInfo info;
145  if (!CNTV2DeviceScanner::GetDeviceInfo (inDeviceIndex, info))
146  return false;
147  sRecursionCheck++; // increment
148  if (sRecursionCheck > RECURSION_LIMIT)
149  {DIFAIL("Failed: " << DEC(RECURSION_LIMIT) << " '.vdev' bounces -- limit exceeded"); return false;}
150  if (!Open(info.vdevUrl))
151  {sRecursionCheck--; return false;} // Open vdev urlSpec failed
152  setDeviceIndexNumber(UWord(info.deviceIndex)); // Patch _boardNumber
153  sRecursionCheck--; // decrement
154  return true;
155  } // if OpenLocalPhysical failed
156 
157 #if !defined(NTV2_ALLOW_OPEN_UNSUPPORTED)
158  // Check if device is officially supported...
159  const NTV2DeviceIDSet legalDeviceIDs(::NTV2GetSupportedDevices());
160  if (legalDeviceIDs.find(_boardID) == legalDeviceIDs.end())
161  {
162  DIFAIL("Device ID " << xHEX0N(_boardID,8) << " (at device index " << inDeviceIndex << ") is not in list of supported devices");
163  Close();
164  return false;
165  }
166 #endif // NTV2_ALLOW_OPEN_UNSUPPORTED
167 
168  // Read driver version...
169  uint16_t drvrVersComps[4] = {0, 0, 0, 0};
170  ULWord driverVersionRaw (0);
171  if (!IsRemote() && !ReadRegister (kVRegDriverVersion, driverVersionRaw))
172  {DIFAIL("ReadRegister(kVRegDriverVersion) failed"); Close(); return false;}
173  drvrVersComps[0] = uint16_t(NTV2DriverVersionDecode_Major(driverVersionRaw)); // major
174  drvrVersComps[1] = uint16_t(NTV2DriverVersionDecode_Minor(driverVersionRaw)); // minor
175  drvrVersComps[2] = uint16_t(NTV2DriverVersionDecode_Point(driverVersionRaw)); // point
176  drvrVersComps[3] = uint16_t(NTV2DriverVersionDecode_Build(driverVersionRaw)); // build
177 
178  // Check driver version (local devices only)
179  NTV2_ASSERT(!IsRemote());
180  if (!(AJA_NTV2_SDK_VERSION_MAJOR))
181  DIWARN ("Driver version v" << DEC(drvrVersComps[0]) << "." << DEC(drvrVersComps[1]) << "." << DEC(drvrVersComps[2]) << "."
182  << DEC(drvrVersComps[3]) << " ignored for client SDK v0.0.0.0 (dev mode), driverVersionRaw=" << xHEX0N(driverVersionRaw,8));
183  else if (drvrVersComps[0] == uint16_t(AJA_NTV2_SDK_VERSION_MAJOR))
184  DIDBG ("Driver v" << DEC(drvrVersComps[0]) << "." << DEC(drvrVersComps[1])
185  << "." << DEC(drvrVersComps[2]) << "." << DEC(drvrVersComps[3]) << " == client SDK v"
186  << DEC(uint16_t(AJA_NTV2_SDK_VERSION_MAJOR)) << "." << DEC(uint16_t(AJA_NTV2_SDK_VERSION_MINOR))
187  << "." << DEC(uint16_t(AJA_NTV2_SDK_VERSION_POINT)) << "." << DEC(uint16_t(AJA_NTV2_SDK_BUILD_NUMBER)));
188  else
189  DIWARN ("Driver v" << DEC(drvrVersComps[0]) << "." << DEC(drvrVersComps[1])
190  << "." << DEC(drvrVersComps[2]) << "." << DEC(drvrVersComps[3]) << " != client SDK v"
191  << DEC(uint16_t(AJA_NTV2_SDK_VERSION_MAJOR)) << "." << DEC(uint16_t(AJA_NTV2_SDK_VERSION_MINOR)) << "."
192  << DEC(uint16_t(AJA_NTV2_SDK_VERSION_POINT)) << "." << DEC(uint16_t(AJA_NTV2_SDK_BUILD_NUMBER))
193  << ", driverVersionRaw=" << xHEX0N(driverVersionRaw,8));
194 
195  FinishOpen();
196  AJAAtomic::Increment(&gOpenCount);
197  DIDBGX(DEC(gOpenCount) << " opened, " << DEC(gCloseCount) << " closed");
198  return true;
199 }
200 
201 // Open remote or virtual device
202 bool CNTV2DriverInterface::Open (const string & inURLSpec)
203 {
204  Close();
205  NTV2_ASSERT(_pRPCAPI == AJA_NULL);
206  const NTV2DeviceSpecParser specParser (inURLSpec);
207  if (specParser.HasErrors())
208  {DIFAIL("Bad device specification '" << inURLSpec << "': " << specParser.Error()); return false;}
209 
210  // URLSpecs can specify locally-attached devices...
211  if (specParser.IsLocalDevice())
212  { // Local device...
213  CNTV2Card card;
214  if (specParser.HasResult(kConnectParamDevSerial))
215  { if (CNTV2DeviceScanner::GetDeviceWithSerial(specParser.DeviceSerial(), card))
216  Open(card.GetIndexNumber());
217  }
218  else if (specParser.HasResult(kConnectParamDevModel))
219  { if (CNTV2DeviceScanner::GetFirstDeviceWithName(specParser.DeviceModel(), card))
220  Open(card.GetIndexNumber());
221  }
222  else if (specParser.HasResult(kConnectParamDevID))
223  { if (CNTV2DeviceScanner::GetFirstDeviceWithID(specParser.DeviceID(), card))
224  Open(card.GetIndexNumber());
225  }
226  else if (specParser.HasResult(kConnectParamDevIndex))
227  Open(specParser.DeviceIndex());
228  if (!IsOpen())
229  {DIFAIL("Failed to open " << specParser.InfoString()); return false;}
230  return true;
231  }
232 
233  // Open the remote/virtual device...
234  if (!OpenRemote(specParser))
235  return false; // Failed to open
236 
237  FinishOpen();
238  AJAAtomic::Increment(&gOpenCount);
239  DIDBGX(DEC(gOpenCount) << " opens, " << DEC(gCloseCount) << " closes");
240  return true;
241 }
242 
243 bool CNTV2DriverInterface::Close (void)
244 {
245  if (IsOpen())
246  {
247  // Unsubscribe all...
248  for (INTERRUPT_ENUMS eInt(eVerticalInterrupt); eInt < eNumInterruptTypes; eInt = INTERRUPT_ENUMS(eInt+1))
249  ConfigureSubscription (false, eInt, mInterruptEventHandles[eInt]);
250 
251  const bool closeOK(IsRemote() ? CloseRemote() : CloseLocalPhysical());
252  if (closeOK)
253  AJAAtomic::Increment(&gCloseCount);
254  _boardID = DEVICE_ID_NOTFOUND;
255  DIDBGX(DEC(gOpenCount) << " opens, " << DEC(gCloseCount) << " closes");
256  return closeOK;
257  }
258  return true;
259 
260 } // Close
261 
262 
263 bool CNTV2DriverInterface::OpenLocalPhysical (const UWord inDeviceIndex)
264 {
265 #if defined(NTV2_NULL_DEVICE)
266  DIFAIL("SDK built with 'NTV2_NULL_DEVICE' defined -- cannot OpenLocalPhysical '" << DEC(inDeviceIndex) << "'");
267 #else // else defined(NTV2_NULL_DEVICE)
268  (void) inDeviceIndex;
269  NTV2_ASSERT(false && "Requires platform-specific implementation");
270 #endif // else NTV2_NULL_DEVICE defined
271  return false;
272 }
273 
274 bool CNTV2DriverInterface::CloseLocalPhysical (void)
275 {
276  NTV2_ASSERT(false && "Requires platform-specific implementation");
277  return false;
278 }
279 
280 #if defined(AJA_WINDOWS)
281  static bool winsock_inited = false;
282  static WSADATA wsaData;
283 
284  static void initWinsock(void)
285  {
286  int wret;
287  if (!winsock_inited)
288  wret = WSAStartup(MAKEWORD(2,2), &wsaData);
289  winsock_inited = true;
290  }
291 #endif // AJA_WINDOWS
292 
293 
294 bool CNTV2DriverInterface::OpenRemote (const NTV2DeviceSpecParser & inParser)
295 {
296 #if defined(AJA_WINDOWS)
297  initWinsock();
298 #endif // defined(AJA_WINDOWS)
299  NTV2_ASSERT(!IsOpen()); // Must be closed!
300  NTV2_ASSERT(_pRPCAPI == AJA_NULL);
301 
302 #if defined(NTV2_NUB_CLIENT_SUPPORT)
303  if (inParser.Failed())
304  {ostringstream errs; inParser.PrintErrors(errs); DIFAIL("Bad parser: " << errs.str()); return false;}
305  if (inParser.IsLocalDevice())
306  {DIFAIL("Parser infers local device: " << inParser.InfoString()); return false;}
307 
308  NTV2Dictionary connectParams(inParser.Results());
309  // This "connectParams" dictionary has keys/values that determine which plugin to load,
310  // and any other configuration parameters specified by the caller. This dictionary is
311  // modified during the call to "CreateClient" (below) by an NTV2PluginLoader that loads,
312  // interrogates and validates the plugin. Several new keys/values are added to it during
313  // this process that describe the plugin, its signature, and any query parameters it
314  // requires or accepts for further configuration.
315  DIDBG("Opening " << inParser.InfoString());
316  NTV2RPCAPI * pClient (NTV2RPCClientAPI::CreateClient(connectParams));
317  if (!pClient)
318  return false; // Failed to instantiate plugin client
319 
320  // At this point, the plugin's NTV2RPCAPI object exists, but may or may not be useable,
321  // depending on if it's "IsConnected". Before SDK 17.1, the plugin's NTV2Connect function
322  // was commonly called directly from its constructor. After SDK 17.1.0, OpenRemote is
323  // responsible for calling NTV2Connect, to allow tools like NTV2Watcher to probe the
324  // plugin in stages via its client interface.
325  if (!pClient->IsConnected())
326  if (!pClient->NTV2Connect())
327  { DIFAIL("Failed to connect/open '" << inParser.DeviceSpec() << "'");
328  delete pClient;
329  CloseRemote();
330  return false;
331  }
332 
333  // NTV2 physical devices always have a hardware identity -- the NTV2DeviceID read from register 50.
334  // This plugin device is considered "open" if ReadRegister is successful, and returns a non-zero
335  // value that's also not DEVICE_ID_NOTFOUND. (Virtual/software devices that have no NTV2 hardware
336  // corollary should return DEVICE_ID_SOFTWARE.)
337  _pRPCAPI = pClient;
338  _boardOpened = ReadRegister(kRegBoardID, _boardID) && _boardID && _boardID != DEVICE_ID_NOTFOUND;
339  if (!IsRemote() || !IsOpen())
340  DIFAIL("Failed to open '" << inParser.DeviceSpec() << "'");
341  return IsRemote() && IsOpen(); // Fail if not remote nor open
342 #else // NTV2_NUB_CLIENT_SUPPORT
343  DIFAIL("SDK built without 'NTV2_NUB_CLIENT_SUPPORT' -- cannot OpenRemote '" << inParser.DeviceSpec() << "'");
344  return false;
345 #endif // NTV2_NUB_CLIENT_SUPPORT
346 } // OpenRemote
347 
348 
349 bool CNTV2DriverInterface::CloseRemote (void)
350 {
351  if (_pRPCAPI)
352  {
353  DIDBG("Closing remote: " << *_pRPCAPI);
354  if (_pRPCAPI->NTV2Disconnect())
355  DIINFO("Remote closed: " << *_pRPCAPI);
356  else
357  DIFAIL("Remote close (NTV2Disconnect) failed: " << *_pRPCAPI);
358  delete _pRPCAPI;
359  _pRPCAPI = AJA_NULL;
360  _boardOpened = false;
361  return true;
362  }
363  // Wasn't open
364  _boardOpened = false;
365  return false;
366 }
367 
368 
369 bool CNTV2DriverInterface::GetInterruptEventCount (const INTERRUPT_ENUMS inInterrupt, ULWord & outCount)
370 {
371  outCount = 0;
372  if (!NTV2_IS_VALID_INTERRUPT_ENUM(inInterrupt))
373  return false;
374  outCount = mEventCounts.at(inInterrupt);
375  return true;
376 }
377 
378 bool CNTV2DriverInterface::SetInterruptEventCount (const INTERRUPT_ENUMS inInterrupt, const ULWord inCount)
379 {
380  if (!NTV2_IS_VALID_INTERRUPT_ENUM(inInterrupt))
381  return false;
382  mEventCounts.at(inInterrupt) = inCount;
383  return true;
384 }
385 
386 bool CNTV2DriverInterface::GetInterruptCount (const INTERRUPT_ENUMS eInterrupt, ULWord & outCount)
387 { (void) eInterrupt;
388  outCount = 0;
389  NTV2_ASSERT(false && "Needs subclass implementation");
390  return false;
391 }
392 
393 HANDLE CNTV2DriverInterface::GetInterruptEvent (const INTERRUPT_ENUMS eInterruptType)
394 {
395  if (!NTV2_IS_VALID_INTERRUPT_ENUM(eInterruptType))
396  return HANDLE(0);
397  return HANDLE(uint64_t(mInterruptEventHandles.at(eInterruptType)));
398 }
399 
400 bool CNTV2DriverInterface::ConfigureInterrupt (const bool bEnable, const INTERRUPT_ENUMS eInterruptType)
401 { (void) bEnable; (void) eInterruptType;
402  NTV2_ASSERT(false && "Needs subclass implementation");
403  return false;
404 }
405 
406 bool CNTV2DriverInterface::ConfigureSubscription (const bool bSubscribe, const INTERRUPT_ENUMS eInterruptType, PULWord & outSubscriptionHdl)
407 {
408  if (!NTV2_IS_VALID_INTERRUPT_ENUM(eInterruptType))
409  return false;
410  outSubscriptionHdl = mInterruptEventHandles.at(eInterruptType);
411  if (bSubscribe)
412  { // If subscribing,
413  mEventCounts [eInterruptType] = 0; // clear this interrupt's event counter
414  DIDBG("Subscribing '" << ::NTV2InterruptEnumString(eInterruptType) << "' (" << UWord(eInterruptType)
415  << "), event counter reset");
416  }
417  else
418  {
419  DIDBGX("Unsubscribing '" << ::NTV2InterruptEnumString(eInterruptType) << "' (" << UWord(eInterruptType) << "), "
420  << mEventCounts[eInterruptType] << " event(s) received");
421  }
422  return true;
423 
424 } // ConfigureSubscription
425 
426 
427 NTV2DeviceID CNTV2DriverInterface::GetDeviceID (void)
428 {
429  ULWord value(0);
430  if (IsOpen() && ReadRegister(kRegBoardID, value))
431  {
432  const NTV2DeviceID currentValue(NTV2DeviceID(value+0));
433  if (currentValue != _boardID)
434  DIWARN(xHEX0N(this,16) << ": NTV2DeviceID " << xHEX0N(value,8) << " (" << ::NTV2DeviceIDToString(currentValue)
435  << ") read from register " << kRegBoardID << " doesn't match _boardID " << xHEX0N(_boardID,8) << " ("
436  << ::NTV2DeviceIDToString(_boardID) << ")");
437  return currentValue;
438  }
439  return DEVICE_ID_NOTFOUND;
440 }
441 
442 
443 // Common remote card read register. Subclasses have overloaded function
444 // that does platform-specific read of register on local card.
445 bool CNTV2DriverInterface::ReadRegister (const ULWord inRegNum, ULWord & outValue, const ULWord inMask, const ULWord inShift)
446 {
447 #if defined(NTV2_NUB_CLIENT_SUPPORT)
448  if (IsRemote())
449  return _pRPCAPI->NTV2ReadRegisterRemote (inRegNum, outValue, inMask, inShift);
450 #else
451  (void) inRegNum; (void) outValue; (void) inMask; (void) inShift;
452 #endif
453  return false;
454 }
455 
456 bool CNTV2DriverInterface::ReadRegisters (NTV2RegisterReads & inOutValues)
457 {
458  if (!IsOpen())
459  return false; // Device not open!
460  if (inOutValues.empty())
461  return true; // Nothing to do!
462 
463  NTV2GetRegisters getRegsParams (inOutValues);
464  if (NTV2Message(reinterpret_cast<NTV2_HEADER*>(&getRegsParams)))
465  {
466  if (!getRegsParams.GetRegisterValues(inOutValues))
467  return false;
468  }
469  else // Non-atomic user-space workaround until GETREGS implemented in driver...
470  for (NTV2RegisterReadsIter iter(inOutValues.begin()); iter != inOutValues.end(); ++iter)
471  if (iter->registerNumber != kRegXenaxFlashDOUT) // Prevent firmware erase/program/verify failures
472  if (!ReadRegister (iter->registerNumber, iter->registerValue))
473  return false;
474  return true;
475 }
476 
477 #if !defined(NTV2_DEPRECATE_16_0)
478  // Common remote card read multiple registers. Subclasses have overloaded function
479  bool CNTV2DriverInterface::ReadRegisterMulti (const ULWord inNumRegs, ULWord * pOutWhichRegFailed, NTV2RegInfo pOutRegInfos[])
480  {
481  if (!pOutWhichRegFailed)
482  return false; // NULL pointer
483  *pOutWhichRegFailed = 0xFFFFFFFF;
484  if (!inNumRegs)
485  return false; // numRegs is zero
486 
487  // New in SDK 16.0: Use ReadRegs NTV2Message
488  NTV2RegReads regReads, result;
489  regReads.reserve(inNumRegs); result.reserve(inNumRegs);
490  for (size_t ndx(0); ndx < size_t(inNumRegs); ndx++)
491  regReads.push_back(pOutRegInfos[ndx]);
492  result = regReads;
493  bool retVal (ReadRegisters(result));
494  NTV2_ASSERT(result.size() <= regReads.size());
495  if (result.size() < regReads.size())
496  *pOutWhichRegFailed = result.empty() ? regReads.front().registerNumber : result.back().registerNumber;
497  return retVal;
498  }
499 
500  Word CNTV2DriverInterface::SleepMs (const LWord milliseconds)
501  {
502  AJATime::Sleep(milliseconds);
503  return 0; // Beware, this function always returns zero, even if sleep was interrupted
504  }
505 #endif // !defined(NTV2_DEPRECATE_16_0)
506 
507 
508 // Common remote card write register. Subclasses overloaded this to do platform-specific register write.
509 bool CNTV2DriverInterface::WriteRegister (const ULWord inRegNum, const ULWord inValue, const ULWord inMask, const ULWord inShift)
510 {
511 #if defined(NTV2_WRITEREG_PROFILING)
512  // Recording is done in platform-specific WriteRegister
513 #endif // NTV2_WRITEREG_PROFILING
514 #if defined(NTV2_NUB_CLIENT_SUPPORT)
515  // If we get here, must be a non-physical device connection...
516  return IsRemote() ? _pRPCAPI->NTV2WriteRegisterRemote(inRegNum, inValue, inMask, inShift) : false;
517 #else
518  (void) inRegNum; (void) inValue; (void) inMask; (void) inShift;
519  return false;
520 #endif
521 }
522 
523 
524 bool CNTV2DriverInterface::DmaTransfer (const NTV2DMAEngine inDMAEngine,
525  const bool inIsRead,
526  const ULWord inFrameNumber,
527  ULWord * pFrameBuffer,
528  const ULWord inCardOffsetBytes,
529  const ULWord inTotalByteCount,
530  const bool inSynchronous)
531 {
532 #if defined(NTV2_NUB_CLIENT_SUPPORT)
533  NTV2_ASSERT(IsRemote());
534  NTV2Buffer buffer(pFrameBuffer, inTotalByteCount);
535  return _pRPCAPI->NTV2DMATransferRemote(inDMAEngine, inIsRead, inFrameNumber, buffer, inCardOffsetBytes,
536  0/*numSegs*/, 0/*hostPitch*/, 0/*cardPitch*/, inSynchronous);
537 #else
538  (void) inDMAEngine; (void) inIsRead; (void) inFrameNumber; (void) pFrameBuffer; (void) inCardOffsetBytes;
539  (void) inTotalByteCount; (void) inSynchronous;
540  return false;
541 #endif
542 }
543 
544 bool CNTV2DriverInterface::DmaTransfer (const NTV2DMAEngine inDMAEngine,
545  const bool inIsRead,
546  const ULWord inFrameNumber,
547  ULWord * pFrameBuffer,
548  const ULWord inCardOffsetBytes,
549  const ULWord inTotalByteCount,
550  const ULWord inNumSegments,
551  const ULWord inHostPitchPerSeg,
552  const ULWord inCardPitchPerSeg,
553  const bool inSynchronous)
554 {
555 #if defined(NTV2_NUB_CLIENT_SUPPORT)
556  NTV2_ASSERT(IsRemote());
557  NTV2Buffer buffer(pFrameBuffer, inTotalByteCount);
558  return _pRPCAPI->NTV2DMATransferRemote(inDMAEngine, inIsRead, inFrameNumber, buffer, inCardOffsetBytes,
559  inNumSegments, inHostPitchPerSeg, inCardPitchPerSeg, inSynchronous);
560 #else
561  (void) inDMAEngine; (void) inIsRead; (void) inFrameNumber; (void) pFrameBuffer; (void) inCardOffsetBytes;
562  (void) inTotalByteCount; (void) inNumSegments; (void) inHostPitchPerSeg; (void) inCardPitchPerSeg; (void) inSynchronous;
563  return false;
564 #endif
565 }
566 
567 bool CNTV2DriverInterface::DmaTransfer (const NTV2DMAEngine inDMAEngine,
568  const NTV2Channel inDMAChannel,
569  const bool inIsTarget,
570  const ULWord inFrameNumber,
571  const ULWord inCardOffsetBytes,
572  const ULWord inByteCount,
573  const ULWord inNumSegments,
574  const ULWord inSegmentHostPitch,
575  const ULWord inSegmentCardPitch,
576  const PCHANNEL_P2P_STRUCT & inP2PData)
577 { (void) inDMAEngine; (void) inDMAChannel; (void) inIsTarget; (void) inFrameNumber; (void) inCardOffsetBytes;
578  (void) inByteCount; (void) inNumSegments; (void) inSegmentHostPitch; (void) inSegmentCardPitch; (void) inP2PData;
579 #if defined(NTV2_NUB_CLIENT_SUPPORT)
580  NTV2_ASSERT(IsRemote());
581  // No NTV2DMATransferP2PRemote implementation yet
582 #endif
583  return false;
584 }
585 
586 // Common remote card waitforinterrupt. Subclasses have overloaded function
587 // that does platform-specific waitforinterrupt on local cards.
588 bool CNTV2DriverInterface::WaitForInterrupt (INTERRUPT_ENUMS eInterrupt, ULWord timeOutMs)
589 {
590 #if defined(NTV2_NUB_CLIENT_SUPPORT)
591  return _pRPCAPI ? _pRPCAPI->NTV2WaitForInterruptRemote(eInterrupt, timeOutMs) : false;
592 #else
593  (void) eInterrupt;
594  (void) timeOutMs;
595  return false;
596 #endif
597 }
598 
599 // Common remote card autocirculate. Subclasses have overloaded function
600 // that does platform-specific autocirculate on local cards.
601 bool CNTV2DriverInterface::AutoCirculate (AUTOCIRCULATE_DATA & autoCircData)
602 {
603 #if defined(NTV2_NUB_CLIENT_SUPPORT)
604  if (IsRemote())
605  switch (autoCircData.eCommand)
606  {
607  case eStartAutoCirc:
608  case eAbortAutoCirc:
609  case ePauseAutoCirc:
610  case eFlushAutoCirculate:
611  case eGetAutoCirc:
612  case eStopAutoCirc:
613  case eInitAutoCirc:
614  case eSetActiveFrame:
615  return _pRPCAPI->NTV2AutoCirculateRemote(autoCircData);
616  default: // Others not handled
617  return false;
618  }
619  return false;
620 #else
621  (void) autoCircData;
622  return false;
623 #endif
624 }
625 
626 bool CNTV2DriverInterface::NTV2Message (NTV2_HEADER * pInMessage)
627 {
628 #if defined(NTV2_NUB_CLIENT_SUPPORT)
629  return _pRPCAPI ? _pRPCAPI->NTV2MessageRemote(pInMessage) : false;
630 #else
631  (void) pInMessage;
632  return false;
633 #endif
634 }
635 
636 
637 // Common remote card DriverGetBitFileInformation. Subclasses have overloaded function
638 // that does platform-specific function on local cards.
639 bool CNTV2DriverInterface::DriverGetBitFileInformation (BITFILE_INFO_STRUCT & bitFileInfo, const NTV2BitFileType bitFileType)
640 { (void)bitFileType;
641  ::memset(&bitFileInfo, 0, sizeof(bitFileInfo));
642  if (IsRemote())
643  return false;
644  if (!::NTV2DeviceHasSPIFlash(_boardID))
645  return false;
646 
647  ParseFlashHeader(bitFileInfo);
648  bitFileInfo.bitFileType = 0;
649  switch (_boardID)
650  {
651  case DEVICE_ID_CORVID1: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID1_MAIN; break;
652  case DEVICE_ID_CORVID22: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID22_MAIN; break;
653  case DEVICE_ID_CORVID24: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID24_MAIN; break;
654  case DEVICE_ID_CORVID3G: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID3G_MAIN; break;
655  case DEVICE_ID_CORVID44: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44; break;
656  case DEVICE_ID_CORVID44_2X4K: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_2X4K_MAIN; break;
657  case DEVICE_ID_CORVID44_8K: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_8K_MAIN; break;
658  case DEVICE_ID_CORVID44_8KMK: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_8KMK_MAIN; break;
659  case DEVICE_ID_CORVID44_GEN3: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_GEN3; break;
660  case DEVICE_ID_CORVID44_PLNR: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_PLNR_MAIN; break;
661  case DEVICE_ID_CORVID88: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID88; break;
662  case DEVICE_ID_CORVID88_GEN3: bitFileInfo.bitFileType = NTV2_BITFILE_CORVID44_GEN3; break;
663  case DEVICE_ID_CORVIDHBR: bitFileInfo.bitFileType = NTV2_BITFILE_NUMBITFILETYPES; break;
664  case DEVICE_ID_CORVIDHEVC: bitFileInfo.bitFileType = NTV2_BITFILE_CORVIDHEVC; break;
665  case DEVICE_ID_IO4K: bitFileInfo.bitFileType = NTV2_BITFILE_IO4K_MAIN; break;
666  case DEVICE_ID_IO4KPLUS: bitFileInfo.bitFileType = NTV2_BITFILE_IO4KPLUS_MAIN; break;
667  case DEVICE_ID_IO4KUFC: bitFileInfo.bitFileType = NTV2_BITFILE_IO4KUFC_MAIN; break;
668  case DEVICE_ID_IOEXPRESS: bitFileInfo.bitFileType = NTV2_BITFILE_IOEXPRESS_MAIN; break;
669  case DEVICE_ID_IOIP_2022: bitFileInfo.bitFileType = NTV2_BITFILE_IOIP_2022; break;
670  case DEVICE_ID_IOIP_2110: bitFileInfo.bitFileType = NTV2_BITFILE_IOIP_2110; break;
671  case DEVICE_ID_IOIP_2110_RGB12: bitFileInfo.bitFileType = NTV2_BITFILE_IOIP_2110_RGB12; break;
672  case DEVICE_ID_IOXT: bitFileInfo.bitFileType = NTV2_BITFILE_IOXT_MAIN; break;
673  case DEVICE_ID_KONA1: bitFileInfo.bitFileType = NTV2_BITFILE_KONA1; break;
674  case DEVICE_ID_KONA3G: bitFileInfo.bitFileType = NTV2_BITFILE_KONA3G_MAIN; break;
675  case DEVICE_ID_KONA3GQUAD: bitFileInfo.bitFileType = NTV2_BITFILE_KONA3G_QUAD; break;
676  case DEVICE_ID_KONA4: bitFileInfo.bitFileType = NTV2_BITFILE_KONA4_MAIN; break;
677  case DEVICE_ID_KONA4UFC: bitFileInfo.bitFileType = NTV2_BITFILE_KONA4UFC_MAIN; break;
678  case DEVICE_ID_KONA5: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_MAIN; break;
679  case DEVICE_ID_KONA5_2X4K: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_2X4K_MAIN; break;
680  case DEVICE_ID_KONA5_3DLUT: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_3DLUT_MAIN; break;
681  case DEVICE_ID_KONA5_8K: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_8K_MAIN; break;
682  case DEVICE_ID_KONA5_8KMK: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_8KMK_MAIN; break;
683  case DEVICE_ID_KONA5_OE1: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE1_MAIN; break;
684  case DEVICE_ID_KONA5_OE2: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE2_MAIN; break;
685  case DEVICE_ID_KONA5_OE3: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE3_MAIN; break;
686  case DEVICE_ID_KONA5_OE4: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE4_MAIN; break;
687  case DEVICE_ID_KONA5_OE5: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE5_MAIN; break;
688  case DEVICE_ID_KONA5_OE6: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE6_MAIN; break;
689  case DEVICE_ID_KONA5_OE7: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE7_MAIN; break;
690  case DEVICE_ID_KONA5_OE8: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE8_MAIN; break;
691  case DEVICE_ID_KONA5_OE9: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE9_MAIN; break;
692  case DEVICE_ID_KONA5_OE10: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE10_MAIN; break;
693  case DEVICE_ID_KONA5_OE11: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE11_MAIN; break;
694  case DEVICE_ID_KONA5_OE12: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_OE12_MAIN; break;
695  case DEVICE_ID_SOJI_OE1: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE1_MAIN; break;
696  case DEVICE_ID_SOJI_OE2: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE2_MAIN; break;
697  case DEVICE_ID_SOJI_OE3: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE3_MAIN; break;
698  case DEVICE_ID_SOJI_OE4: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE4_MAIN; break;
699  case DEVICE_ID_SOJI_OE5: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE5_MAIN; break;
700  case DEVICE_ID_SOJI_OE6: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE6_MAIN; break;
701  case DEVICE_ID_SOJI_OE7: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_OE7_MAIN; break;
702  case DEVICE_ID_SOJI_3DLUT: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_3DLUT_MAIN; break;
703  case DEVICE_ID_SOJI_DIAGS: bitFileInfo.bitFileType = NTV2_BITFILE_SOJI_DIAGS_MAIN; break;
704  case DEVICE_ID_KONA5_8K_MV_TX: bitFileInfo.bitFileType = NTV2_BITFILE_KONA5_8K_MV_TX_MAIN; break;
705  case DEVICE_ID_KONAHDMI: bitFileInfo.bitFileType = NTV2_BITFILE_KONAHDMI; break;
706  case DEVICE_ID_KONAIP_1RX_1TX_1SFP_J2K: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_1RX_1TX_1SFP_J2K; break;
707  case DEVICE_ID_KONAIP_1RX_1TX_2110: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_1RX_1TX_2110; break;
708  case DEVICE_ID_KONAIP_2022: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_2022; break;
709  case DEVICE_ID_KONAIP_2110: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_2110; break;
710  case DEVICE_ID_KONAIP_2110_RGB12: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_2110_RGB12; break;
711  case DEVICE_ID_KONAIP_2TX_1SFP_J2K: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_2TX_1SFP_J2K; break;
712  case DEVICE_ID_KONAIP_4CH_2SFP: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_4CH_2SFP; break;
713  case DEVICE_ID_KONALHEPLUS: bitFileInfo.bitFileType = NTV2_BITFILE_KONALHE_PLUS; break;
714  case DEVICE_ID_KONALHI: bitFileInfo.bitFileType = NTV2_BITFILE_LHI_MAIN; break;
715  case DEVICE_ID_KONALHIDVI: bitFileInfo.bitFileType = NTV2_BITFILE_NUMBITFILETYPES; break;
716  case DEVICE_ID_TTAP: bitFileInfo.bitFileType = NTV2_BITFILE_TTAP_MAIN; break;
717  case DEVICE_ID_TTAP_PRO: bitFileInfo.bitFileType = NTV2_BITFILE_TTAP_PRO_MAIN; break;
718  case DEVICE_ID_IOX3: bitFileInfo.bitFileType = NTV2_BITFILE_IOX3_MAIN; break;
719  case DEVICE_ID_KONAX: bitFileInfo.bitFileType = NTV2_BITFILE_KONAX; break;
720  case DEVICE_ID_KONAXM: bitFileInfo.bitFileType = NTV2_BITFILE_KONAXM; break;
721  case DEVICE_ID_KONAX_4CH: bitFileInfo.bitFileType = NTV2_BITFILE_KONAX_4CH; break;
722  case DEVICE_ID_KONAIP_25G: bitFileInfo.bitFileType = NTV2_BITFILE_KONAIP_25G; break;
723 
724  case DEVICE_ID_IP25_T:
725  case DEVICE_ID_IP25_R:
726  case DEVICE_ID_SOFTWARE:
727  case DEVICE_ID_NOTFOUND: bitFileInfo.bitFileType = NTV2_BITFILE_TYPE_INVALID; break;
728  #if !defined (_DEBUG)
729  default: break;
730  #endif
731  }
732  bitFileInfo.checksum = 0;
733  bitFileInfo.structVersion = 0;
734  bitFileInfo.structSize = sizeof(BITFILE_INFO_STRUCT);
735  bitFileInfo.whichFPGA = eFPGAVideoProc;
736 
737  const string bitFileDesignNameString = string(bitFileInfo.designNameStr) + ".bit";
738  ::strncpy(bitFileInfo.designNameStr, bitFileDesignNameString.c_str(), sizeof(bitFileInfo.designNameStr)-1);
739  return true;
740 }
741 
742 bool CNTV2DriverInterface::GetPackageInformation (PACKAGE_INFO_STRUCT & packageInfo)
743 {
744  if (!IsDeviceReady(false) || !IsSupported(kDeviceCanDoIP))
745  return false; // cannot read flash
746 
747  string packInfo;
748  ULWord deviceID = ULWord(_boardID);
749  ReadRegister (kRegBoardID, deviceID);
750 
751  if (CNTV2AxiSpiFlash::DeviceSupported(NTV2DeviceID(deviceID)))
752  {
753  CNTV2AxiSpiFlash spiFlash(GetIndexNumber(), false);
754 
755  uint32_t offset = spiFlash.Offset(SPI_FLASH_SECTION_MCSINFO);
756  vector<uint8_t> mcsInfoData;
757  if (spiFlash.Read(offset, mcsInfoData, 256))
758  {
759  packInfo.assign(mcsInfoData.begin(), mcsInfoData.end());
760 
761  // remove any trailing nulls
762  size_t found = packInfo.find('\0');
763  if (found != string::npos)
764  {
765  packInfo.resize(found);
766  }
767  }
768  else
769  return false;
770  }
771  else
772  {
773  ULWord baseAddress = (16 * 1024 * 1024) - (3 * 256 * 1024);
774  const ULWord dwordSizeCount = 256/4;
775 
776  WriteRegister(kRegXenaxFlashAddress, ULWord(1)); // bank 1
777  WriteRegister(kRegXenaxFlashControlStatus, 0x17);
778  bool busy = true;
779  ULWord timeoutCount = 1000;
780  do
781  {
782  ULWord regValue;
783  ReadRegister(kRegXenaxFlashControlStatus, regValue);
784  if (regValue & BIT(8))
785  {
786  busy = true;
787  timeoutCount--;
788  }
789  else
790  busy = false;
791  } while (busy == true && timeoutCount > 0);
792  if (timeoutCount == 0)
793  return false;
794 
795  ULWord* bitFilePtr = new ULWord[dwordSizeCount];
796  for ( ULWord count = 0; count < dwordSizeCount; count++, baseAddress += 4 )
797  {
798  WriteRegister(kRegXenaxFlashAddress, baseAddress);
799  WriteRegister(kRegXenaxFlashControlStatus, 0x0B);
800  busy = true;
801  timeoutCount = 1000;
802  do
803  {
804  ULWord regValue;
805  ReadRegister(kRegXenaxFlashControlStatus, regValue);
806  if ( regValue & BIT(8))
807  {
808  busy = true;
809  timeoutCount--;
810  }
811  else
812  busy = false;
813  } while(busy == true && timeoutCount > 0);
814  if (timeoutCount == 0)
815  {
816  delete [] bitFilePtr;
817  return false;
818  }
819  ReadRegister(kRegXenaxFlashDOUT, bitFilePtr[count]);
820  }
821 
822  packInfo = reinterpret_cast<char*>(bitFilePtr);
823  delete [] bitFilePtr;
824  }
825 
826  istringstream iss(packInfo);
827  vector<string> results;
828  string token;
829  while (getline(iss,token, ' '))
830  results.push_back(token);
831 
832  if (results.size() < 8)
833  return false;
834 
835  packageInfo.date = results[1];
836  token = results[2];
837  token.erase(remove(token.begin(), token.end(), '\n'), token.end());
838  packageInfo.time = token;
839  packageInfo.buildNumber = results[4];
840  packageInfo.packageNumber = results[7];
841  return true;
842 }
843 
844 // Common remote card DriverGetBuildInformation. Subclasses have overloaded function
845 // that does platform-specific function on local cards.
846 bool CNTV2DriverInterface::DriverGetBuildInformation (BUILD_INFO_STRUCT & buildInfo)
847 {
848  ::memset(&buildInfo, 0, sizeof(buildInfo));
849  return false;
850 }
851 
852 bool CNTV2DriverInterface::BitstreamWrite (const NTV2Buffer & inBuffer, const bool inFragment, const bool inSwap)
853 {
854  NTV2Bitstream bsMsg (inBuffer,
855  BITSTREAM_WRITE |
856  (inFragment? BITSTREAM_FRAGMENT : 0) |
857  (inSwap? BITSTREAM_SWAP : 0));
858  ULWord counts(0);
859  ReadRegister(kVRegDynFirmwareUpdateCounts, counts);
860  ULWord attempts(counts >> 16), successes(counts & 0x0000FFFF);
861  attempts++;
862  const bool result (NTV2Message (reinterpret_cast<NTV2_HEADER*>(&bsMsg)));
863  if (result)
864  successes++;
865  counts = (attempts << 16) | successes;
866  WriteRegister(kVRegDynFirmwareUpdateCounts, counts);
867  return result;
868 }
869 
870 bool CNTV2DriverInterface::BitstreamReset (const bool inConfiguration, const bool inInterface)
871 {
872  NTV2Buffer inBuffer;
873  NTV2Bitstream bsMsg (inBuffer,
874  (inConfiguration? BITSTREAM_RESET_CONFIG : 0) |
875  (inInterface? BITSTREAM_RESET_MODULE : 0));
876  return NTV2Message(bsMsg);
877 }
878 
879 bool CNTV2DriverInterface::BitstreamStatus (NTV2ULWordVector & outRegValues)
880 {
881  outRegValues.reserve(BITSTREAM_MCAP_DATA);
882  outRegValues.clear();
883 
884  NTV2Buffer inBuffer;
885  NTV2Bitstream bsMsg (inBuffer, BITSTREAM_READ_REGISTERS);
886  if (!NTV2Message(bsMsg))
887  return false;
888 
889  for (UWord ndx(0); ndx < BITSTREAM_MCAP_DATA; ndx++)
890  outRegValues.push_back(bsMsg.mRegisters[ndx]);
891 
892  return true;
893 }
894 
895 bool CNTV2DriverInterface::BitstreamLoad (const bool inSuspend, const bool inResume)
896 {
897  NTV2Buffer inBuffer;
898  NTV2Bitstream bsMsg (inBuffer,
899  (inSuspend? BITSTREAM_SUSPEND : 0) |
900  (inResume? BITSTREAM_RESUME : 0));
901  return NTV2Message(bsMsg);
902 }
903 
904 bool CNTV2DriverInterface::StreamChannelOps (const NTV2Channel inChannel,
905  ULWord flags,
906  NTV2StreamChannel& status)
907 {
908  status.mChannel = inChannel;
909  status.mFlags = flags;
910 
911  return NTV2Message(status);
912 }
913 
914 bool CNTV2DriverInterface::StreamBufferOps (const NTV2Channel inChannel,
915  NTV2Buffer& inBuffer,
916  ULWord64 bufferCookie,
917  ULWord flags,
918  NTV2StreamBuffer& status)
919 {
920  status.mChannel = inChannel;
921  status.mBuffer.Set (inBuffer.GetHostPointer(), inBuffer.GetByteCount());
922  status.mBufferCookie = bufferCookie;
923  status.mFlags = flags;
924 
925  return NTV2Message(status);
926 }
927 
928 bool CNTV2DriverInterface::MailBufferOps (const NTV2Channel inChannel,
929  NTV2Buffer& inBuffer,
930  ULWord dataSize,
931  ULWord flags,
932  ULWord delay,
933  ULWord timeout,
934  NTV2MailBuffer& status)
935 {
936  status.mChannel = inChannel;
937  status.mBuffer.Set (inBuffer.GetHostPointer(), inBuffer.GetByteCount());
938  status.mDataSize = dataSize;
939  status.mDelay = delay;
940  status.mTimeout = timeout;
941  status.mFlags = flags;
942 
943  return NTV2Message(status);
944 }
945 
946 // FinishOpen
947 // NOTE _boardID must be set before calling this routine.
948 void CNTV2DriverInterface::FinishOpen (void)
949 {
950  // HACK! FinishOpen needs frame geometry to determine frame buffer size and number.
951  NTV2FrameGeometry fg(NTV2_FG_INVALID);
952  ULWord val1(0), val2(0);
953  ReadRegister (kRegGlobalControl, fg, kRegMaskGeometry, kRegShiftGeometry); // Read FrameGeometry
954  ReadRegister (kRegCh1Control, val1, kRegMaskFrameFormat, kRegShiftFrameFormat); // Read PixelFormat
955  ReadRegister (kRegCh1Control, val2, kRegMaskFrameFormatHiBit, kRegShiftFrameFormatHiBit);
956  NTV2PixelFormat pf(NTV2PixelFormat((val1 & 0x0F) | ((val2 & 0x1) << 4)));
957 #if !defined(NTV2_DEPRECATE_17_2)
958  _ulFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID, fg, pf);
959  _ulNumFrameBuffers = ::NTV2DeviceGetNumberFrameBuffers(_boardID, fg, pf);
960 #endif
961 
962  ULWord returnVal1 = false;
963  ULWord returnVal2 = false;
964  if (::NTV2DeviceCanDo4KVideo(_boardID))
965  ReadRegister(kRegGlobalControl2, returnVal1, kRegMaskQuadMode, kRegShiftQuadMode);
966  if (::NTV2DeviceCanDo425Mux(_boardID))
967  ReadRegister(kRegGlobalControl2, returnVal2, kRegMask425FB12, kRegShift425FB12);
968 
969 #if !defined(NTV2_DEPRECATE_16_0)
970  _pFrameBaseAddress = AJA_NULL;
971  _pRegisterBaseAddress = AJA_NULL;
972  _pRegisterBaseAddressLength = 0;
973  _pXena2FlashBaseAddress = AJA_NULL;
974  _pCh1FrameBaseAddress = AJA_NULL;
975  _pCh2FrameBaseAddress = AJA_NULL;
976 #endif // !defined(NTV2_DEPRECATE_16_0)
977 
978 } // FinishOpen
979 
980 
981 bool CNTV2DriverInterface::ParseFlashHeader (BITFILE_INFO_STRUCT & bitFileInfo)
982 {
983  if (!IsDeviceReady(false))
984  return false; // cannot read flash
985 
986  if (::NTV2DeviceGetSPIFlashVersion(_boardID) == 4)
987  {
988  uint32_t val;
989  ReadRegister((0x100000 + 0x08) / 4, val);
990  if (val != 0x01)
991  return false; // cannot read flash
992  }
993 
994  if (::NTV2DeviceGetSPIFlashVersion(_boardID) >= 3 && ::NTV2DeviceGetSPIFlashVersion(_boardID) <= 5)
995  {
996  WriteRegister(kRegXenaxFlashAddress, 0ULL);
997  WriteRegister(kRegXenaxFlashControlStatus, 0x17);
998  bool busy = true;
999  ULWord timeoutCount = 1000;
1000  do
1001  {
1002  ULWord regValue;
1003  ReadRegister(kRegXenaxFlashControlStatus, regValue);
1004  if (regValue & BIT(8))
1005  {
1006  busy = true;
1007  timeoutCount--;
1008  }
1009  else
1010  busy = false;
1011  } while (busy && timeoutCount);
1012  if (!timeoutCount)
1013  return false;
1014  }
1015 
1016  // Allocate header buffer, read/fill from SPI-flash...
1017  static const ULWord dwordCount(256/4);
1018  NTV2Buffer bitFileHdrBuffer(dwordCount * sizeof(ULWord));
1019  if (!bitFileHdrBuffer)
1020  return false;
1021 
1022  ULWord* pULWord(bitFileHdrBuffer), baseAddress(0);
1023  for (ULWord count(0); count < dwordCount; count++, baseAddress += 4)
1024  if (!ReadFlashULWord(baseAddress, pULWord[count]))
1025  return false;
1026 
1027  CNTV2Bitfile fileInfo;
1028  std::string headerError;
1029 #if 0 // Fake out:
1030  if (_boardID == DEVICE_ID_TTAP_PRO) // Fake TTapPro -- load "flash" from on-disk bitfile:
1031  { fileInfo.Open("/Users/demo/dev-svn/firmware/T3_Tap/t_tap_pro.bit");
1032  headerError = fileInfo.GetLastError();
1033  } else
1034 #endif
1035  headerError = fileInfo.ParseHeaderFromBuffer(bitFileHdrBuffer);
1036  if (headerError.empty())
1037  {
1038  ::strncpy(bitFileInfo.dateStr, fileInfo.GetDate().c_str(), NTV2_BITFILE_DATETIME_STRINGLENGTH);
1039  ::strncpy(bitFileInfo.timeStr, fileInfo.GetTime().c_str(), NTV2_BITFILE_DATETIME_STRINGLENGTH);
1040  ::strncpy(bitFileInfo.designNameStr, fileInfo.GetDesignName().c_str(), NTV2_BITFILE_DESIGNNAME_STRINGLENGTH);
1041  ::strncpy(bitFileInfo.partNameStr, fileInfo.GetPartName().c_str(), NTV2_BITFILE_PARTNAME_STRINGLENGTH);
1042  bitFileInfo.numBytes = ULWord(fileInfo.GetProgramStreamLength());
1043  }
1044  return headerError.empty();
1045 } // ParseFlashHeader
1046 
1047 bool CNTV2DriverInterface::ReadFlashULWord (const ULWord inAddress, ULWord & outValue, const ULWord inRetryCount)
1048 {
1049  if (!WriteRegister(kRegXenaxFlashAddress, inAddress))
1050  return false;
1051  if (!WriteRegister(kRegXenaxFlashControlStatus, 0x0B))
1052  return false;
1053  bool busy(true);
1054  ULWord timeoutCount(inRetryCount);
1055  do
1056  {
1057  ULWord regValue(0);
1058  ReadRegister(kRegXenaxFlashControlStatus, regValue);
1059  if (regValue & BIT(8))
1060  {
1061  busy = true;
1062  timeoutCount--;
1063  }
1064  else
1065  busy = false;
1066  } while (busy && timeoutCount);
1067  if (!timeoutCount)
1068  return false;
1069  return ReadRegister(kRegXenaxFlashDOUT, outValue);
1070 }
1071 
1072 void CNTV2DriverInterface::setDeviceIndexNumber (const UWord num)
1073 {
1074  _boardNumber = num;
1075 }
1076 
1077 
1078 //--------------------------------------------------------------------------------------------------------------------
1079 // Application acquire and release stuff
1080 //--------------------------------------------------------------------------------------------------------------------
1081 const uint32_t kAgentAppFcc (NTV2_FOURCC('A','j','a','A'));
1082 
1083 
1084 bool CNTV2DriverInterface::AcquireStreamForApplicationWithReference (const ULWord inAppCode, const int32_t inProcessID)
1085 {
1086  ULWord svcInitialized(0);
1087  if (ReadRegister(kVRegServicesInitialized, svcInitialized))
1088  if (!svcInitialized) // if services have never initialized the device
1089  if (inAppCode != kAgentAppFcc) // if not AJA Agent
1090  DIWARN(::NTV2DeviceIDToString(GetDeviceID()) << "-" << DEC(GetIndexNumber())
1091  << " uninitialized by AJAAgent, requesting app " << xHEX0N(inAppCode,8) << ", pid=" << DEC(inProcessID));
1092 
1093  ULWord currentCode(0), currentPID(0);
1094  if (!ReadRegister(kVRegApplicationCode, currentCode) || !ReadRegister(kVRegApplicationPID, currentPID))
1095  return false;
1096 
1097  // Check if owner is deceased
1098  if (!AJAProcess::IsValid(currentPID))
1099  {
1100  // Process doesn't exist, so make the board our own
1101  ReleaseStreamForApplication (currentCode, int32_t(currentPID));
1102  }
1103 
1104  if (!ReadRegister(kVRegApplicationCode, currentCode) || !ReadRegister(kVRegApplicationPID, currentPID))
1105  return false;
1106 
1107  for (int count(0); count < 20; count++)
1108  {
1109  if (!currentPID)
1110  {
1111  // Nothing has the board
1112  if (!WriteRegister(kVRegApplicationCode, inAppCode))
1113  return false;
1114  // Just in case this is not zero
1115  WriteRegister(kVRegAcquireLinuxReferenceCount, 0);
1116  WriteRegister(kVRegAcquireLinuxReferenceCount, 1);
1117  return WriteRegister(kVRegApplicationPID, ULWord(inProcessID));
1118  }
1119  else if (currentCode == inAppCode && currentPID == ULWord(inProcessID))
1120  return WriteRegister(kVRegAcquireLinuxReferenceCount, 1); // Process already acquired, so bump the count
1121  // Someone else has the board, so wait and try again
1122  AJATime::Sleep(50);
1123  }
1124  return false;
1125 }
1126 
1127 bool CNTV2DriverInterface::ReleaseStreamForApplicationWithReference (const ULWord inAppCode, const int32_t inProcessID)
1128 {
1129  ULWord currentCode(0), currentPID(0), currentCount(0);
1130  if (!ReadRegister(kVRegApplicationCode, currentCode)
1131  || !ReadRegister(kVRegApplicationPID, currentPID)
1132  || !ReadRegister(kVRegAcquireLinuxReferenceCount, currentCount))
1133  return false;
1134 
1135  if (currentCode == inAppCode && currentPID == ULWord(inProcessID))
1136  {
1137  if (currentCount > 1)
1138  return WriteRegister(kVRegReleaseLinuxReferenceCount, 1);
1139  if (currentCount == 1)
1140  return ReleaseStreamForApplication(inAppCode, inProcessID);
1141  return true;
1142  }
1143  return false;
1144 }
1145 
1146 bool CNTV2DriverInterface::AcquireStreamForApplication (const ULWord inAppCode, const int32_t inProcessID)
1147 {
1148  ULWord svcInitialized(0);
1149  if (ReadRegister(kVRegServicesInitialized, svcInitialized))
1150  if (!svcInitialized) // if services have never initialized the device
1151  if (inAppCode != kAgentAppFcc) // if not AJA Agent
1152  DIWARN(::NTV2DeviceIDToString(GetDeviceID()) << "-" << DEC(GetIndexNumber())
1153  << " uninitialized by AJAAgent, requesting app " << xHEX0N(inAppCode,8) << ", pid=" << DEC(inProcessID));
1154 
1155  // Loop for a while trying to acquire the board
1156  for (int count(0); count < 20; count++)
1157  {
1158  if (WriteRegister(kVRegApplicationCode, inAppCode))
1159  return WriteRegister(kVRegApplicationPID, ULWord(inProcessID));
1160  AJATime::Sleep(50);
1161  }
1162 
1163  // Get data about current owner
1164  ULWord currentCode(0), currentPID(0);
1165  if (!ReadRegister(kVRegApplicationCode, currentCode) || !ReadRegister(kVRegApplicationPID, currentPID))
1166  return false;
1167 
1168  // Check if owner is deceased
1169  if (!AJAProcess::IsValid(currentPID))
1170  { // Process doesn't exist, so make the board our own
1171  ReleaseStreamForApplication (currentCode, int32_t(currentPID));
1172  for (int count(0); count < 20; count++)
1173  {
1174  if (WriteRegister(kVRegApplicationCode, inAppCode))
1175  return WriteRegister(kVRegApplicationPID, ULWord(inProcessID));
1176  AJATime::Sleep(50);
1177  }
1178  }
1179  // Current owner is alive, so don't interfere
1180  return false;
1181 }
1182 
1183 bool CNTV2DriverInterface::ReleaseStreamForApplication (const ULWord inAppCode, const int32_t inProcessID)
1184 { (void)inAppCode; // Don't care which appCode
1185  if (WriteRegister(kVRegReleaseApplication, ULWord(inProcessID)))
1186  {
1187  WriteRegister(kVRegAcquireLinuxReferenceCount, 0);
1188  return true; // We don't care if the above call failed
1189  }
1190  return false;
1191 }
1192 
1193 bool CNTV2DriverInterface::SetStreamingApplication (const ULWord inAppCode, const int32_t inProcessID)
1194 {
1195  if (!WriteRegister(kVRegForceApplicationCode, inAppCode))
1196  return false;
1197  return WriteRegister(kVRegForceApplicationPID, ULWord(inProcessID));
1198 }
1199 
1200 bool CNTV2DriverInterface::GetStreamingApplication (ULWord & outAppType, int32_t & outProcessID)
1201 {
1202  if (!ReadRegister(kVRegApplicationCode, outAppType))
1203  return false;
1204  return CNTV2DriverInterface::ReadRegister(kVRegApplicationPID, outProcessID);
1205 }
1206 
1207 string CNTV2DriverInterface::GetDescription (void) const
1208 {
1209  if (!IsRemote())
1210  return ""; // This implementation is intended for remote/plugin devices
1211  string desc(_pRPCAPI->Description());
1212  if (desc.empty())
1213  { // Plugin/remote device didn't provide description
1214  const NTV2Dictionary parms(ConnectParams());
1215  NTV2StringList strs;
1216  if (parms.hasKey(kNTV2PluginRegInfoKey_LongName))
1217  strs.push_back("\"" + parms.valueForKey(kNTV2PluginRegInfoKey_LongName) + "\"");
1218  else if (parms.hasKey(kNTV2PluginRegInfoKey_ShortName))
1219  strs.push_back(parms.valueForKey(kNTV2PluginRegInfoKey_ShortName));
1220  if (parms.hasKey(kNTV2PluginRegInfoKey_Description))
1221  strs.push_back(parms.valueForKey(kNTV2PluginRegInfoKey_Description));
1222  else if (parms.hasKey(kNTV2PluginRegInfoKey_Copyright))
1223  strs.push_back(parms.valueForKey(kNTV2PluginRegInfoKey_Copyright));
1224  else if (parms.hasKey(kNTV2PluginRegInfoKey_Vendor))
1225  strs.push_back(parms.valueForKey(kNTV2PluginRegInfoKey_Vendor));
1226  if (!strs.empty())
1227  desc = aja::join(strs, ", ");
1228  }
1229  return desc;
1230 }
1231 
1232 NTV2Dictionary CNTV2DriverInterface::ConnectParams (void) const
1233 {
1234  return IsRemote() ? _pRPCAPI->ConnectParams() : NTV2Dictionary();
1235 }
1236 
1237 // This function is used by the retail ControlPanel.
1238 // Read the current RP188 registers (which typically give you the timecode corresponding to the LAST frame).
1239 // NOTE: This is a hack to avoid making a "real" driver call! Since the RP188 data requires three ReadRegister()
1240 // calls, there is a chance that it can straddle a VBI, which could give bad results. To avoid this, we
1241 // read the 3 registers until we get two consecutive passes that give us the same data. (Someday it'd
1242 // be nice if the driver automatically read these as part of its VBI IRQ handler...
1243 bool CNTV2DriverInterface::ReadRP188Registers (const NTV2Channel inChannel, RP188_STRUCT * pRP188Data)
1244 { (void) inChannel;
1245  if (!pRP188Data)
1246  return false;
1247 
1248  RP188_STRUCT rp188;
1249  NTV2DeviceID boardID = DEVICE_ID_NOTFOUND;
1250  RP188SourceFilterSelect source = kRP188SourceEmbeddedLTC;
1251  ULWord dbbReg(0), msReg(0), lsReg(0);
1252 
1253  CNTV2DriverInterface::ReadRegister(kRegBoardID, boardID);
1254  CNTV2DriverInterface::ReadRegister(kVRegRP188SourceSelect, source);
1255  bool bLTCPort = (source == kRP188SourceLTCPort);
1256 
1257  // values come from LTC port registers
1258  if (bLTCPort)
1259  {
1260  ULWord ltcPresent;
1261  ReadRegister (kRegStatus, ltcPresent, kRegMaskLTCInPresent, kRegShiftLTCInPresent);
1262 
1263  // there is no equivalent DBB for LTC port - we synthesize it here
1264  rp188.DBB = (ltcPresent) ? 0xFE000000 | NEW_SELECT_RP188_RCVD : 0xFE000000;
1265 
1266  // LTC port registers
1267  dbbReg = 0; // don't care - does not exist
1268  msReg = kRegLTCAnalogBits0_31;
1269  lsReg = kRegLTCAnalogBits32_63;
1270  }
1271  else
1272  {
1273  // values come from RP188 registers
1274  NTV2Channel channel = NTV2_CHANNEL1;
1275  NTV2InputVideoSelect inputSelect = NTV2_Input1Select;
1276 
1277  if (::NTV2DeviceGetNumVideoInputs(boardID) > 1)
1278  {
1279  CNTV2DriverInterface::ReadRegister (kVRegInputSelect, inputSelect);
1280  channel = (inputSelect == NTV2_Input2Select) ? NTV2_CHANNEL2 : NTV2_CHANNEL1;
1281  }
1282  else
1283  channel = NTV2_CHANNEL1;
1284 
1285  // rp188 registers
1286  dbbReg = (channel == NTV2_CHANNEL1 ? kRegRP188InOut1DBB : kRegRP188InOut2DBB);
1287  //Check to see if TC is received
1288  uint32_t tcReceived = 0;
1289  ReadRegister(dbbReg, tcReceived, BIT(16), 16);
1290  if(tcReceived == 0)
1291  return false;//No TC recevied
1292 
1293  ReadRegister (dbbReg, rp188.DBB, kRegMaskRP188DBB, kRegShiftRP188DBB );
1294  switch (rp188.DBB)//What do we have?
1295  {
1296  default:
1297  case 0x01:
1298  case 0x02:
1299  {
1300  //We have VITC - what do we want?
1301  if (pRP188Data->DBB == 0x01 || pRP188Data->DBB == 0x02)
1302  { // We want VITC
1303  msReg = (channel == NTV2_CHANNEL1 ? kRegRP188InOut1Bits0_31 : kRegRP188InOut2Bits0_31 );
1304  lsReg = (channel == NTV2_CHANNEL1 ? kRegRP188InOut1Bits32_63 : kRegRP188InOut2Bits32_63);
1305  }
1306  else
1307  { // We want Embedded LTC, so we should check one other place
1308  uint32_t ltcPresent = 0;
1309  ReadRegister(dbbReg, ltcPresent, BIT(18), 18);
1310  if (ltcPresent != 1)
1311  return false;
1312  //Read LTC registers
1313  msReg = (channel == NTV2_CHANNEL1 ? kRegLTCEmbeddedBits0_31 : kRegLTC2EmbeddedBits0_31 );
1314  lsReg = (channel == NTV2_CHANNEL1 ? kRegLTCEmbeddedBits32_63 : kRegLTC2EmbeddedBits32_63);
1315  }
1316  break;
1317  }
1318  case 0x00:
1319  //We have LTC - do we want it?
1320  if (pRP188Data->DBB != 0x00)
1321  return false;
1322  msReg = (channel == NTV2_CHANNEL1 ? kRegRP188InOut1Bits0_31 : kRegRP188InOut2Bits0_31 );
1323  lsReg = (channel == NTV2_CHANNEL1 ? kRegRP188InOut1Bits32_63 : kRegRP188InOut2Bits32_63);
1324  break;
1325  }
1326  //Re-Read the whole register just in case something is expecting other status values
1327  ReadRegister (dbbReg, rp188.DBB);
1328  }
1329  ReadRegister (msReg, rp188.Low );
1330  ReadRegister (lsReg, rp188.High);
1331 
1332  // register stability filter
1333  do
1334  {
1335  *pRP188Data = rp188; // struct copy to result
1336 
1337  // read again into local struct
1338  if (!bLTCPort)
1339  ReadRegister (dbbReg, rp188.DBB);
1340  ReadRegister (msReg, rp188.Low );
1341  ReadRegister (lsReg, rp188.High);
1342 
1343  // if the new read equals the previous read, consider it done
1344  if (rp188.DBB == pRP188Data->DBB &&
1345  rp188.Low == pRP188Data->Low &&
1346  rp188.High == pRP188Data->High)
1347  break;
1348  } while (true);
1349 
1350  return true;
1351 }
1352 
1353 void CNTV2DriverInterface::BumpEventCount (const INTERRUPT_ENUMS eInterruptType)
1354 {
1355  if (NTV2_IS_VALID_INTERRUPT_ENUM(eInterruptType))
1356  mEventCounts[eInterruptType] += 1;
1357 
1358 } // BumpEventCount
1359 
1360 
1361 bool CNTV2DriverInterface::IsDeviceReady (const bool checkValid)
1362 {
1363  if (IsRemote())
1364  {
1365  ULWord reg(0), val(0);
1366  if (!ReadRegister(kVRegVDevReadyRegNum, reg))
1367  return true; // failed to read VReg -- assume ready
1368  if (!reg)
1369  return true; // reg number is zero -- assume ready
1370  // A non-zero register number was returned (hope it's valid)
1371  if (!ReadRegister(reg, val))
1372  return true; // failed to read -- bad reg num? -- assume device ready
1373  // ReadRegister successful!
1374  return val; // zero means "not ready"; non-zero means "ready"
1375  }
1376  if (!IsSupported(kDeviceCanDoIP) && !IsSupported(kDeviceCanDo25GIP))
1377  return true; // Non-IP devices always ready
1378 
1379  if (IsSupported(kDeviceCanDoIP))
1380  {
1381  if (!IsMBSystemReady())
1382  return false;
1383 
1384  if (checkValid && !IsMBSystemValid())
1385  return false;
1386  }
1387  else if (!IsLPSystemReady())
1388  return false;
1389  return true; // Ready!
1390 }
1391 
1392 bool CNTV2DriverInterface::IsMBSystemValid (void)
1393 {
1394  if (IsSupported(kDeviceCanDoIP))
1395  {
1396  uint32_t val;
1397  ReadRegister(SAREK_REGS + kRegSarekIfVersion, val);
1398  return val == SAREK_IF_VERSION;
1399  }
1400  return true;
1401 }
1402 
1403 bool CNTV2DriverInterface::IsMBSystemReady (void)
1404 {
1405  if (!IsSupported(kDeviceCanDoIP))
1406  return false; // No microblaze
1407 
1408  uint32_t val;
1409  ReadRegister(SAREK_REGS + kRegSarekMBState, val);
1410  if (val != 0x01)
1411  return false; // MB not ready
1412 
1413  // Not enough to read MB State, we need to make sure MB is running
1414  ReadRegister(SAREK_REGS + kRegSarekMBUptime, val);
1415  return (val < 2) ? false : true;
1416 }
1417 
1418 bool CNTV2DriverInterface::IsLPSystemReady (void)
1419 {
1420  if (!IsSupported(kDeviceCanDo25GIP))
1421  return false; // No local proc
1422 
1423  uint32_t val;
1424  ReadRegister(kRegReserved83, val);
1425  if (val == 0x00)
1426  return false; // MB not ready
1427  return true;
1428 }
1429 
1430 #if defined(NTV2_WRITEREG_PROFILING) // Register Write Profiling
1431  bool CNTV2DriverInterface::GetRecordedRegisterWrites (NTV2RegisterWrites & outRegWrites) const
1432  {
1433  AJAAutoLock autoLock(&mRegWritesLock);
1434  outRegWrites = mRegWrites;
1435  return true;
1436  }
1437 
1438  bool CNTV2DriverInterface::StartRecordRegisterWrites (const bool inSkipActualWrites)
1439  {
1440  AJAAutoLock autoLock(&mRegWritesLock);
1441  if (mRecordRegWrites)
1442  return false; // Already recording
1443  mRegWrites.clear();
1444  mRecordRegWrites = true;
1445  mSkipRegWrites = inSkipActualWrites;
1446  return true;
1447  }
1448 
1449  bool CNTV2DriverInterface::ResumeRecordRegisterWrites (void)
1450  { // Identical to Start, but don't clear mRegWrites nor change mSkipRegWrites
1451  AJAAutoLock autoLock(&mRegWritesLock);
1452  if (mRecordRegWrites)
1453  return false; // Already recording
1454  mRecordRegWrites = true;
1455  return true;
1456  }
1457 
1458  bool CNTV2DriverInterface::IsRecordingRegisterWrites (void) const
1459  { // NB: This will return false if paused
1460  AJAAutoLock autoLock(&mRegWritesLock);
1461  return mRecordRegWrites;
1462  }
1463 
1464  bool CNTV2DriverInterface::StopRecordRegisterWrites (void)
1465  {
1466  AJAAutoLock autoLock(&mRegWritesLock);
1467  mRecordRegWrites = mSkipRegWrites = false;
1468  return true;
1469  }
1470 
1471  bool CNTV2DriverInterface::PauseRecordRegisterWrites (void)
1472  { // Identical to Stop, but don't change mSkipRegWrites
1473  AJAAutoLock autoLock(&mRegWritesLock);
1474  if (!mRecordRegWrites)
1475  return false; // Already stopped/paused
1476  mRecordRegWrites = false;
1477  return true;
1478  }
1479 
1480  ULWord CNTV2DriverInterface::GetNumRecordedRegisterWrites (void) const
1481  {
1482  AJAAutoLock autoLock(&mRegWritesLock);
1483  return ULWord(mRegWrites.size());
1484  }
1485 #endif // NTV2_WRITEREG_PROFILING
1486 
1487 
1488 ULWordSet CNTV2DriverInterface::GetSupportedItems (const NTV2EnumsID inEnumsID)
1489 {
1490  ULWordSet result;
1491  if (!IsOpen())
1492  return result;
1493 
1494  // Remote/virtual device gets first dibs on answering...
1495  if (IsRemote() && _pRPCAPI->NTV2GetSupportedRemote (inEnumsID, result))
1496  return result;
1497 
1498  const NTV2DeviceID devID(GetDeviceID());
1499  switch (inEnumsID)
1500  {
1501  case kNTV2EnumsID_DeviceID:
1502  { const NTV2DeviceIDSet devIDs(::NTV2GetSupportedDevices());
1503  for (NTV2DeviceIDSetConstIter it(devIDs.begin()); it != devIDs.end(); ++it)
1504  result.insert(ULWord(*it));
1505  break;
1506  }
1507  case kNTV2EnumsID_Standard:
1508  { NTV2StandardSet standards;
1509  ::NTV2DeviceGetSupportedStandards (devID, standards);
1510  for (NTV2StandardSetConstIter it(standards.begin()); it != standards.end(); ++it)
1511  result.insert(ULWord(*it));
1512  break;
1513  }
1514  case kNTV2EnumsID_PixelFormat:
1515  { NTV2FrameBufferFormatSet pfs;
1516  ::NTV2DeviceGetSupportedPixelFormats (devID, pfs);
1517  for (NTV2FrameBufferFormatSetConstIter it(pfs.begin()); it != pfs.end(); ++it)
1518  result.insert(ULWord(*it));
1519  break;
1520  }
1521  case kNTV2EnumsID_FrameGeometry:
1522  { NTV2GeometrySet fgs;
1523  ::NTV2DeviceGetSupportedGeometries (devID, fgs);
1524  for (NTV2GeometrySetConstIter it(fgs.begin()); it != fgs.end(); ++it)
1525  result.insert(ULWord(*it));
1526  break;
1527  }
1528  case kNTV2EnumsID_FrameRate:
1529  { NTV2FrameRateSet frs;
1530  ::NTV2DeviceGetSupportedFrameRates (devID, frs);
1531  for (NTV2FrameRateSetConstIter it(frs.begin()); it != frs.end(); ++it)
1532  result.insert(ULWord(*it));
1533  break;
1534  }
1535  case kNTV2EnumsID_ScanGeometry:
1536  { // Needs implementation
1537  break;
1538  }
1539  case kNTV2EnumsID_VideoFormat:
1540  { NTV2VideoFormatSet vfs;
1541  ::NTV2DeviceGetSupportedVideoFormats (devID, vfs);
1542  for (NTV2VideoFormatSetConstIter it(vfs.begin()); it != vfs.end(); ++it)
1543  result.insert(ULWord(*it));
1544  break;
1545  }
1546  case kNTV2EnumsID_Mode:
1547  { if (IsSupported(kDeviceCanDoPlayback)) result.insert(ULWord(NTV2_MODE_OUTPUT));
1548  if (IsSupported(kDeviceCanDoCapture)) result.insert(ULWord(NTV2_MODE_INPUT));
1549  break;
1550  }
1551  case kNTV2EnumsID_InputSource:
1552  { NTV2InputSourceSet srcs;
1553  ::NTV2DeviceGetSupportedInputSources (devID, srcs);
1554  for (NTV2InputSourceSetConstIter it(srcs.begin()); it != srcs.end(); ++it)
1555  result.insert(ULWord(*it));
1556  break;
1557  }
1558  case kNTV2EnumsID_OutputDest:
1559  { NTV2OutputDestinations dsts;
1560  ::NTV2DeviceGetSupportedOutputDests (devID, dsts);
1561  for (NTV2OutputDestinationsConstIter it(dsts.begin()); it != dsts.end(); ++it)
1562  result.insert(ULWord(*it));
1563  break;
1564  }
1565  case kNTV2EnumsID_Channel:
1566  { for (ULWord ch(0); ch < GetNumSupported(kDeviceGetNumFrameStores); ch++)
1567  result.insert(ch);
1568  break;
1569  }
1570  case kNTV2EnumsID_RefSource:
1571  { if (!IsSupported(kDeviceCanDoPlayback))
1572  break;
1573  NTV2InputSourceSet inpSrcs;
1574  ::NTV2DeviceGetSupportedInputSources (devID, inpSrcs);
1575  for (NTV2InputSourceSetConstIter it(inpSrcs.begin()); it != inpSrcs.end(); ++it)
1576  { const NTV2ReferenceSource refSrc (::NTV2InputSourceToReferenceSource(*it));
1577  if (NTV2_IS_VALID_NTV2ReferenceSource(refSrc))
1578  if (result.find(ULWord(refSrc)) == result.end())
1579  result.insert(ULWord(refSrc));
1580  }
1581  result.insert(ULWord(NTV2_REFERENCE_FREERUN)); // Always include Free-Run
1582  if (GetNumSupported(kDeviceGetNumReferenceVideoInputs))
1583  result.insert(ULWord(NTV2_REFERENCE_EXTERNAL)); // Has external reference
1584  break;
1585  }
1586  case kNTV2EnumsID_AudioRate:
1587  { result.insert(ULWord(NTV2_AUDIO_48K)); // All boards support 48KHz PCM
1588  if (IsSupported(kDeviceCanDoAudio96K)) result.insert(ULWord(NTV2_AUDIO_96K));
1589  if (IsSupported(kDeviceCanDoAudio192K)) result.insert(ULWord(NTV2_AUDIO_192K));
1590  break;
1591  }
1592  case kNTV2EnumsID_AudioSource:
1593  { if (!IsSupported(kDeviceCanDoCapture))
1594  break;
1595  NTV2InputSourceSet inpSrcs;
1596  ::NTV2DeviceGetSupportedInputSources (devID, inpSrcs);
1597  for (NTV2InputSourceSetConstIter it(inpSrcs.begin()); it != inpSrcs.end(); ++it)
1598  { const NTV2AudioSource audSrc (::NTV2InputSourceToAudioSource(*it));
1599  if (NTV2_IS_VALID_AUDIO_SOURCE(audSrc))
1600  if (result.find(ULWord(audSrc)) == result.end())
1601  result.insert(ULWord(audSrc));
1602  }
1603  break;
1604  }
1605  case kNTV2EnumsID_WidgetID:
1606  { NTV2WidgetIDSet wgts;
1607  CNTV2SignalRouter::GetWidgetIDs (devID, wgts);
1608  for (NTV2WidgetIDSetConstIter it(wgts.begin()); it != wgts.end(); ++it)
1609  result.insert(ULWord(*it));
1610  break;
1611  }
1612  case kNTV2EnumsID_ConversionMode:
1613  { for (NTV2ConversionMode cm(NTV2_1080i_5994to525_5994); cm < NTV2_NUM_CONVERSIONMODES; cm = NTV2ConversionMode(cm+1))
1614  if (::NTV2DeviceCanDoConversionMode (devID, cm))
1615  result.insert(ULWord(cm));
1616  break;
1617  }
1618  case kNTV2EnumsID_InputTCIndex:
1619  { for (NTV2TCIndex ndx(NTV2_TCINDEX_DEFAULT); ndx < NTV2_MAX_NUM_TIMECODE_INDEXES; ndx = NTV2TCIndex(ndx+1))
1620  if (::NTV2DeviceCanDoInputTCIndex (devID, ndx))
1621  result.insert(ULWord(ndx));
1622  break;
1623  }
1624  case kNTV2EnumsID_OutputTCIndex:
1625  { for (NTV2TCIndex ndx(NTV2_TCINDEX_DEFAULT); ndx < NTV2_MAX_NUM_TIMECODE_INDEXES; ndx = NTV2TCIndex(ndx+1))
1626  if (::NTV2DeviceCanDoOutputTCIndex (devID, ndx))
1627  result.insert(ULWord(ndx));
1628  break;
1629  }
1630  default: break;
1631  }
1632  return result;
1633 }
1634 
1635 bool CNTV2DriverInterface::GetBoolParam (const ULWord inParamID, ULWord & outValue)
1636 {
1637  // Remote/virtual device gets first dibs on answering...
1638  if (IsRemote() && _pRPCAPI->NTV2GetBoolParamRemote (inParamID, outValue))
1639  return true;
1640 
1641  // Is there a register/bit that will answer this query?
1642  const NTV2BoolParamID paramID (NTV2BoolParamID(inParamID+0));
1643  { NTV2RegInfo regInfo; bool invertSense(false);
1644  if (GetRegInfoForBoolParam (paramID, regInfo, invertSense))
1645  {
1646  if (!ReadRegister (regInfo.registerNumber, regInfo.registerValue, regInfo.registerMask, regInfo.registerShift))
1647  return false;
1648  if (invertSense)
1649  outValue = regInfo.registerValue ? 0 : 1;
1650  else
1651  outValue = regInfo.registerValue ? 1 : 0;
1652  return true;
1653  }
1654  }
1655 
1656  // Call classic device features function...
1657  const NTV2DeviceID devID (GetDeviceID());
1658  switch (inParamID)
1659  {
1660  case kDeviceCanChangeEmbeddedAudioClock: outValue = ::NTV2DeviceCanChangeEmbeddedAudioClock(devID); break; // Deprecate?
1661  case kDeviceCanChangeFrameBufferSize: outValue = ::NTV2DeviceCanChangeFrameBufferSize(devID); break;
1662  case kDeviceCanDisableUFC: outValue = ::NTV2DeviceCanDisableUFC(devID); break;
1663  case kDeviceCanDo2KVideo: outValue = ::NTV2DeviceCanDo2KVideo(devID); break;
1664  case kDeviceCanDo3GLevelConversion: outValue = ::NTV2DeviceCanDo3GLevelConversion(devID); break;
1665  case kDeviceCanDoRGBLevelAConversion: outValue = ::NTV2DeviceCanDoRGBLevelAConversion(devID); break;
1666  case kDeviceCanDo425Mux: outValue = ::NTV2DeviceCanDo425Mux(devID); break;
1667  case kDeviceCanDo4KVideo: outValue = ::NTV2DeviceCanDo4KVideo(devID); break;
1668  case kDeviceCanDoAESAudioIn: outValue = GetNumSupported(kDeviceGetNumAESAudioInputChannels) > 0; break;
1669  case kDeviceCanDoAESAudioOut: outValue = GetNumSupported(kDeviceGetNumAESAudioOutputChannels) > 0;break;
1670  case kDeviceCanDoAnalogAudio: outValue = ::NTV2DeviceCanDoAnalogAudio(devID); break;
1671  case kDeviceCanDoAnalogVideoIn: outValue = ::NTV2DeviceCanDoAnalogVideoIn(devID); break;
1672  case kDeviceCanDoAnalogVideoOut: outValue = ::NTV2DeviceCanDoAnalogVideoOut(devID); break;
1673  case kDeviceCanDoAudio2Channels: outValue = GetNumSupported(kDeviceGetMaxAudioChannels) >= 2; break; // Deprecate?
1674  case kDeviceCanDoAudio6Channels: outValue = GetNumSupported(kDeviceGetMaxAudioChannels) >= 6; break; // Deprecate?
1675  case kDeviceCanDoAudio8Channels: outValue = GetNumSupported(kDeviceGetMaxAudioChannels) >= 8; break; // Deprecate?
1676  case kDeviceCanDoAudio96K: outValue = ::NTV2DeviceCanDoAudio96K(devID); break; // Deprecate?
1677  case kDeviceCanDoAudioDelay: outValue = ::NTV2DeviceCanDoAudioDelay(devID); break; // Deprecate?
1678  case kDeviceCanDoAudioInput: outValue = (GetNumSupported(kDeviceGetNumVideoInputs)
1679  + GetNumSupported(kDeviceGetNumHDMIAudioInputChannels)
1680  + GetNumSupported(kDeviceGetNumAESAudioInputChannels)
1681  + GetNumSupported(kDeviceGetNumAnalogAudioInputChannels)) > 0;break;
1682  case kDeviceCanDoAudioOutput: outValue = (GetNumSupported(kDeviceGetNumVideoOutputs)
1683  + GetNumSupported(kDeviceGetNumHDMIAudioOutputChannels)
1684  + GetNumSupported(kDeviceGetNumAESAudioOutputChannels)
1685  + GetNumSupported(kDeviceGetNumAnalogAudioOutputChannels)) > 0;break;
1686  case kDeviceCanDoBreakoutBoard: outValue = ::NTV2DeviceCanDoBreakoutBoard(devID); break;
1687  case kDeviceCanDoBreakoutBox: outValue = ::NTV2DeviceCanDoBreakoutBox(devID); break;
1688  case kDeviceCanDoCapture: outValue = (GetNumSupported(kDeviceGetNumVideoInputs)
1689  + GetNumSupported(kDeviceGetNumHDMIVideoInputs)
1690  + GetNumSupported(kDeviceGetNumAnalogVideoInputs)) > 0; break;
1691  case kDeviceCanDoColorCorrection: outValue = GetNumSupported(kDeviceGetNumLUTs) > 0; break; // Deprecate?
1692  case kDeviceCanDoCustomAnc: outValue = ::NTV2DeviceCanDoCustomAnc(devID); break; // Deprecate?
1693 
1694  // FOR NOW: kDeviceCanDoCustomHancInsertion
1695  // REMOVE THIS CASE ONCE ALL KONA5 & CORVID44/12G & KONAX FIRMWARE SETS kRegCanDoStatus BIT(2):
1696  case kDeviceCanDoCustomHancInsertion: outValue = devID == DEVICE_ID_IO4KPLUS
1697  || devID == DEVICE_ID_KONA5 || devID == DEVICE_ID_KONA5_2X4K
1698  || devID == DEVICE_ID_KONA5_8K || devID == DEVICE_ID_KONA5_3DLUT
1699  || devID == DEVICE_ID_KONA5_8K_MV_TX || devID == DEVICE_ID_CORVID44_8KMK
1700  || devID == DEVICE_ID_CORVID44_8K || devID == DEVICE_ID_CORVID44_2X4K
1701  || devID == DEVICE_ID_CORVID44_PLNR || devID == DEVICE_ID_KONAX
1702  || devID == DEVICE_ID_KONAX_4CH;
1703  break;
1704 
1705  case kDeviceCanDoDSKOpacity: outValue = ::NTV2DeviceCanDoDSKOpacity(devID); break; // Deprecate?
1706  case kDeviceCanDoDualLink: outValue = ::NTV2DeviceCanDoDualLink(devID); break; // Deprecate?
1707  case kDeviceCanDoDVCProHD: outValue = ::NTV2DeviceCanDoDVCProHD(devID); break; // Deprecate?
1708  case kDeviceCanDoEnhancedCSC: outValue = ::NTV2DeviceCanDoEnhancedCSC(devID); break; // Deprecate?
1709  case kDeviceCanDoFrameStore1Display: outValue = ::NTV2DeviceCanDoFrameStore1Display(devID); break; // Deprecate?
1710  case kDeviceCanDoGPIO: outValue = ::NTV2DeviceCanDoGPIO(devID); break;
1711  case kDeviceCanDoHDMIOutStereo: outValue = ::NTV2DeviceCanDoHDMIOutStereo(devID); break; // Deprecate?
1712  case kDeviceCanDoHDV: outValue = ::NTV2DeviceCanDoHDV(devID); break; // Deprecate?
1713  case kDeviceCanDoHDVideo: outValue = ::NTV2DeviceCanDoHDVideo(devID); break; // Deprecate?
1714  case kDeviceCanDoIsoConvert: outValue = ::NTV2DeviceCanDoIsoConvert(devID); break;
1715  case kDeviceCanDoLTC: outValue = ::NTV2DeviceCanDoLTC(devID); break;
1716  case kDeviceCanDoLTCInOnRefPort: outValue = ::NTV2DeviceCanDoLTCInOnRefPort(devID); break;
1717  case kDeviceCanDoMSI: outValue = ::NTV2DeviceCanDoMSI(devID); break;
1718  case kDeviceCanDoMultiFormat: outValue = ::NTV2DeviceCanDoMultiFormat(devID); break;
1719  case kDeviceCanDoPCMControl: outValue = ::NTV2DeviceCanDoPCMControl(devID); break;
1720  case kDeviceCanDoPCMDetection: outValue = ::NTV2DeviceCanDoPCMDetection(devID); break;
1721  case kDeviceCanDoPIO: outValue = ::NTV2DeviceCanDoPIO(devID); break; // Deprecate?
1722  case kDeviceCanDoPlayback: outValue = (GetNumSupported(kDeviceGetNumVideoOutputs)
1723  + GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
1724  + GetNumSupported(kDeviceGetNumAnalogVideoOutputs)) > 0;break;
1725  case kDeviceCanDoProgrammableCSC: outValue = GetNumSupported(kDeviceGetNumCSCs) > 0; break;
1726  case kDeviceCanDoProgrammableRS422: outValue = ::NTV2DeviceCanDoProgrammableRS422(devID); break;
1727  case kDeviceCanDoProRes: outValue = ::NTV2DeviceCanDoProRes(devID); break;
1728  case kDeviceCanDoQREZ: outValue = ::NTV2DeviceCanDoQREZ(devID); break;
1729  case kDeviceCanDoQuarterExpand: outValue = ::NTV2DeviceCanDoQuarterExpand(devID); break;
1730  case kDeviceCanDoRateConvert: outValue = ::NTV2DeviceCanDoRateConvert(devID); break; // Deprecate?
1731  case kDeviceCanDoRGBPlusAlphaOut: outValue = ::NTV2DeviceCanDoRGBPlusAlphaOut(devID); break; // Deprecate?
1732  case kDeviceCanDoRP188: outValue = ::NTV2DeviceCanDoRP188(devID); break; // Deprecate?
1733  case kDeviceCanDoSDVideo: outValue = ::NTV2DeviceCanDoSDVideo(devID); break; // Deprecate?
1734  case kDeviceCanDoSDIErrorChecks: outValue = ::NTV2DeviceCanDoSDIErrorChecks(devID); break;
1735  case kDeviceCanDoStackedAudio: outValue = ::NTV2DeviceCanDoStackedAudio(devID); break; // Deprecate?
1736  case kDeviceCanDoStereoIn: outValue = ::NTV2DeviceCanDoStereoIn(devID); break; // Deprecate?
1737  case kDeviceCanDoStereoOut: outValue = ::NTV2DeviceCanDoStereoOut(devID); break; // Deprecate?
1738  case kDeviceCanDoThunderbolt: outValue = ::NTV2DeviceCanDoThunderbolt(devID); break;
1739  case kDeviceCanDoVideoProcessing: outValue = ::NTV2DeviceCanDoVideoProcessing(devID); break;
1740  case kDeviceCanMeasureTemperature: outValue = ::NTV2DeviceCanMeasureTemperature(devID); break;
1741  case kDeviceCanReportFrameSize: outValue = ::NTV2DeviceCanReportFrameSize(devID); break;
1742  case kDeviceHasBiDirectionalSDI: outValue = ::NTV2DeviceHasBiDirectionalSDI(devID); break;
1743  case kDeviceHasBracketLED: outValue = ::NTV2DeviceHasBracketLED(devID); break;
1744  case kDeviceHasColorSpaceConverterOnChannel2: outValue = ::NTV2DeviceCanDoWidget(devID, NTV2_WgtCSC2); break; // Deprecate?
1745  case kDeviceHasIDSwitch: outValue = ::NTV2DeviceCanDoIDSwitch(devID); break;
1746  case kDeviceHasNTV4FrameStores: outValue = ::NTV2DeviceHasNTV4FrameStores(devID); break;
1747  case kDeviceHasNWL: outValue = ::NTV2DeviceHasNWL(devID); break;
1748  case kDeviceHasPCIeGen2: outValue = ::NTV2DeviceHasPCIeGen2(devID); break;
1749  case kDeviceHasRetailSupport: outValue = ::NTV2DeviceHasRetailSupport(devID); break;
1750  case kDeviceHasSDIRelays: outValue = ::NTV2DeviceHasSDIRelays(devID); break;
1751  case kDeviceHasSPIFlash: outValue = ::NTV2DeviceHasSPIFlash(devID); break; // Deprecate?
1752  case kDeviceHasSPIFlashSerial: outValue = ::NTV2DeviceHasSPIFlashSerial(devID); break; // Deprecate?
1753  case kDeviceHasSPIv2: outValue = GetNumSupported(kDeviceGetSPIFlashVersion) == 2; break;
1754  case kDeviceHasSPIv3: outValue = GetNumSupported(kDeviceGetSPIFlashVersion) == 3; break;
1755  case kDeviceHasSPIv4: outValue = GetNumSupported(kDeviceGetSPIFlashVersion) == 4; break;
1756  case kDeviceIs64Bit: outValue = ::NTV2DeviceIs64Bit(devID); break; // Deprecate?
1757  case kDeviceIsDirectAddressable: outValue = ::NTV2DeviceIsDirectAddressable(devID); break; // Deprecate?
1758  case kDeviceIsExternalToHost: outValue = ::NTV2DeviceIsExternalToHost(devID); break;
1759  case kDeviceIsLocalPhysical: outValue = !IsRemote(); break;
1760  case kDeviceIsSupported: outValue = ::NTV2DeviceIsSupported(devID); break;
1761  case kDeviceNeedsRoutingSetup: outValue = ::NTV2DeviceNeedsRoutingSetup(devID); break; // Deprecate?
1762  case kDeviceSoftwareCanChangeFrameBufferSize: outValue = ::NTV2DeviceSoftwareCanChangeFrameBufferSize(devID); break;
1763  case kDeviceCanThermostat: outValue = ::NTV2DeviceCanThermostat(devID); break;
1764  case kDeviceHasHEVCM31: outValue = ::NTV2DeviceHasHEVCM31(devID); break;
1765  case kDeviceHasHEVCM30: outValue = ::NTV2DeviceHasHEVCM30(devID); break;
1766  case kDeviceCanDoVITC2: outValue = ::NTV2DeviceCanDoVITC2(devID); break;
1767  case kDeviceCanDoHDMIHDROut: outValue = ::NTV2DeviceCanDoHDMIHDROut(devID); break;
1768  case kDeviceCanDoJ2K: outValue = ::NTV2DeviceCanDoJ2K(devID); break;
1769 
1770  case kDeviceCanDo12gRouting: outValue = ::NTV2DeviceCanDo12gRouting(devID); break;
1771  case kDeviceCanDo12GSDI: outValue = ::NTV2DeviceCanDo12GSDI(devID); break;
1772  case kDeviceCanDo2110: outValue = ::NTV2DeviceCanDo2110(devID); break;
1773  case kDeviceCanDo8KVideo: outValue = ::NTV2DeviceCanDo8KVideo(devID); break;
1774  case kDeviceCanDoAudio192K: outValue = ::NTV2DeviceCanDoAudio192K(devID); break;
1775  case kDeviceCanDoHDMIAuxCapture: outValue = ::NTV2DeviceCanDoCustomAux(devID); break;
1776  case kDeviceCanDoHDMIAuxPlayback: outValue = false && ::NTV2DeviceCanDoCustomAux(devID); break; // SDK 17.1 HDMI AUX is Capture-Only
1777  case kDeviceCanDoFramePulseSelect: outValue = ::NTV2DeviceCanDoFramePulseSelect(devID); break;
1778  case kDeviceCanDoHDMIMultiView: outValue = ::NTV2DeviceCanDoHDMIMultiView(devID); break;
1779  case kDeviceCanDoHFRRGB: outValue = ::NTV2DeviceCanDoHFRRGB(devID); break;
1780  case kDeviceCanDoIP: outValue = ::NTV2DeviceCanDoIP(devID); break;
1781  case kDeviceCanDo25GIP: outValue = ::NTV2DeviceCanDo25GIP(devID); break;
1782  case kDeviceCanDoMultiLinkAudio: outValue = ::NTV2DeviceCanDoMultiLinkAudio(devID); break;
1783  case kDeviceCanDoWarmBootFPGA: outValue = ::NTV2DeviceCanDoWarmBootFPGA(devID); break;
1784  case kDeviceCanReportFailSafeLoaded: outValue = ::NTV2DeviceCanReportFailSafeLoaded(devID); break;
1785  case kDeviceCanReportRunningFirmwareDate: outValue = ::NTV2DeviceCanReportRunningFirmwareDate(devID); break;
1786  case kDeviceHasAudioMonitorRCAJacks: outValue = ::NTV2DeviceHasAudioMonitorRCAJacks(devID); break;
1787  case kDeviceHasBiDirectionalAnalogAudio: outValue = ::NTV2DeviceHasBiDirectionalAnalogAudio(devID); break;
1788  case kDeviceHasGenlockv2: outValue = GetNumSupported(kDeviceGetGenlockVersion) == 2; break; // Deprecate
1789  case kDeviceHasGenlockv3: outValue = GetNumSupported(kDeviceGetGenlockVersion) == 3; break; // Deprecate
1790  case kDeviceHasHeadphoneJack: outValue = ::NTV2DeviceHasHeadphoneJack(devID); break;
1791  case kDeviceHasLEDAudioMeters: outValue = ::NTV2DeviceHasLEDAudioMeters(devID); break;
1792  case kDeviceHasRotaryEncoder: outValue = ::NTV2DeviceHasRotaryEncoder(devID); break;
1793  case kDeviceHasSPIv5: outValue = ::NTV2DeviceGetSPIFlashVersion(devID) == 5; break;
1794  case kDeviceHasXilinxDMA: outValue = ::NTV2DeviceHasXilinxDMA(devID); break;
1795  case kDeviceCanDoStreamingDMA: outValue = GetDeviceID() == DEVICE_ID_KONAXM; break;
1796  case kDeviceHasPWMFanControl: outValue = ::NTV2DeviceHasPWMFanControl(devID); break;
1797  case kDeviceCanDoHDMIQuadRasterConversion: outValue = (GetNumSupported(kDeviceGetNumHDMIVideoInputs)
1798  || GetNumSupported(kDeviceGetNumHDMIVideoOutputs)) // At least 1 HDMI in/out
1799  && (GetDeviceID() != DEVICE_ID_KONAHDMI) // Not a KonaHDMI
1800  && (!IsSupported(kDeviceCanDoAudioMixer)); // No audio mixer
1801  break;
1802  case kDeviceROMHasBankSelect: outValue = GetNumSupported(kDeviceGetSPIFlashVersion) >= 3
1803  && GetNumSupported(kDeviceGetSPIFlashVersion) <= 6; break;
1804  case kDeviceCanDoVersalSysMon: outValue = ::NTV2DeviceCanDoVersalSysMon(devID); break;
1805  case kDeviceCanDoAudioMixer:
1806  case kDeviceHasMicrophoneInput:
1807  default: return false; // Bad param
1808  }
1809  return true; // Successfully used old ::NTV2DeviceCanDo function
1810 
1811 } // GetBoolParam
1812 
1813 
1814 bool CNTV2DriverInterface::GetNumericParam (const ULWord inParamID, ULWord & outVal)
1815 {
1816  outVal = 0;
1817 
1818  // Remote/virtual device gets first dibs on answering...
1819  if (IsRemote() && _pRPCAPI->NTV2GetNumericParamRemote (inParamID, outVal))
1820  return true;
1821 
1822  // Is there a register that will answer this query?
1823  const NTV2NumericParamID paramID (NTV2NumericParamID(inParamID+0));
1824  { NTV2RegInfo regInfo;
1825  if (GetRegInfoForNumericParam (paramID, regInfo))
1826  return ReadRegister (regInfo.registerNumber, outVal, regInfo.registerMask, regInfo.registerShift);
1827  }
1828 
1829  // Call classic device features function...
1830  const NTV2DeviceID devID (GetDeviceID());
1831  switch (paramID)
1832  {
1833  case kDeviceGetActiveMemorySize: outVal = ::NTV2DeviceGetActiveMemorySize (devID); break;
1834  case kDeviceGetDACVersion: outVal = ::NTV2DeviceGetDACVersion (devID); break;
1835  case kDeviceGetDownConverterDelay: outVal = ::NTV2DeviceGetDownConverterDelay (devID); break;
1836  case kDeviceGetGenlockVersion: outVal = ULWord(::NTV2DeviceGetGenlockVersion (devID)); break;
1837  case kDeviceGetHDMIVersion: outVal = ::NTV2DeviceGetHDMIVersion (devID); break;
1838  case kDeviceGetLUTVersion: outVal = ::NTV2DeviceGetLUTVersion (devID); break;
1839  case kDeviceGetMaxAudioChannels: outVal = ::NTV2DeviceGetMaxAudioChannels (devID); break;
1840  case kDeviceGetMaxRegisterNumber: outVal = ::NTV2DeviceGetMaxRegisterNumber (devID); break;
1841  case kDeviceGetMaxTransferCount: outVal = ::NTV2DeviceGetMaxTransferCount (devID); break;
1842  case kDeviceGetNum2022ChannelsSFP1: outVal = ::NTV2DeviceGetNum2022ChannelsSFP1 (devID); break;
1843  case kDeviceGetNum2022ChannelsSFP2: outVal = ::NTV2DeviceGetNum2022ChannelsSFP2 (devID); break;
1844  case kDeviceGetNum4kQuarterSizeConverters: outVal = ::NTV2DeviceGetNum4kQuarterSizeConverters (devID); break;
1845  case kDeviceGetNumAESAudioInputChannels: outVal = ::NTV2DeviceGetNumAESAudioInputChannels (devID); break;
1846  case kDeviceGetNumAESAudioOutputChannels: outVal = ::NTV2DeviceGetNumAESAudioOutputChannels (devID); break;
1847  case kDeviceGetNumAnalogAudioInputChannels: outVal = ::NTV2DeviceGetNumAnalogAudioInputChannels (devID); break;
1848  case kDeviceGetNumAnalogAudioOutputChannels: outVal = ::NTV2DeviceGetNumAnalogAudioOutputChannels (devID); break;
1849  case kDeviceGetNumAnalogVideoInputs: outVal = ::NTV2DeviceGetNumAnalogVideoInputs (devID); break;
1850  case kDeviceGetNumAnalogVideoOutputs: outVal = ::NTV2DeviceGetNumAnalogVideoOutputs (devID); break;
1851  case kDeviceGetNumAudioSystems: outVal = ::NTV2DeviceGetNumAudioSystems (devID); break;
1852  case kDeviceGetNumBufferedAudioSystems: outVal = ::NTV2DeviceGetNumAudioSystems(devID)
1853  + (IsSupported(kDeviceCanDoAudioMixer) ? 1 : 0); break;
1854  case kDeviceGetNumCrossConverters: outVal = ::NTV2DeviceGetNumCrossConverters (devID); break;
1855  case kDeviceGetNumCSCs: outVal = ::NTV2DeviceGetNumCSCs (devID); break;
1856  case kDeviceGetNumDMAEngines: outVal = ::NTV2DeviceGetNumDMAEngines (devID); break;
1857  case kDeviceGetNumDownConverters: outVal = ::NTV2DeviceGetNumDownConverters (devID); break;
1858  case kDeviceGetNumEmbeddedAudioInputChannels: outVal = ::NTV2DeviceGetNumEmbeddedAudioInputChannels (devID); break;
1859  case kDeviceGetNumEmbeddedAudioOutputChannels: outVal = ::NTV2DeviceGetNumEmbeddedAudioOutputChannels (devID); break;
1860  case kDeviceGetNumFrameStores: outVal = ::NTV2DeviceGetNumFrameStores (devID); break;
1861  case kDeviceGetNumFrameSyncs: outVal = ::NTV2DeviceGetNumFrameSyncs (devID); break;
1862  case kDeviceGetNumHDMIAudioInputChannels: outVal = ::NTV2DeviceGetNumHDMIAudioInputChannels (devID); break;
1863  case kDeviceGetNumHDMIAudioOutputChannels: outVal = ::NTV2DeviceGetNumHDMIAudioOutputChannels (devID); break;
1864  case kDeviceGetNumHDMIVideoInputs: outVal = ::NTV2DeviceGetNumHDMIVideoInputs (devID); break;
1865  case kDeviceGetNumHDMIVideoOutputs: outVal = ::NTV2DeviceGetNumHDMIVideoOutputs (devID); break;
1866  case kDeviceGetNumInputConverters: outVal = ::NTV2DeviceGetNumInputConverters (devID); break;
1867  case kDeviceGetNumLTCInputs: outVal = ::NTV2DeviceGetNumLTCInputs (devID); break;
1868  case kDeviceGetNumLTCOutputs: outVal = ::NTV2DeviceGetNumLTCOutputs (devID); break;
1869  case kDeviceGetNumLUTs: outVal = ::NTV2DeviceGetNumLUTs (devID); break;
1870  case kDeviceGetNumMixers: outVal = ::NTV2DeviceGetNumMixers (devID); break;
1871  case kDeviceGetNumOutputConverters: outVal = ::NTV2DeviceGetNumOutputConverters (devID); break;
1872  case kDeviceGetNumReferenceVideoInputs: outVal = ::NTV2DeviceGetNumReferenceVideoInputs (devID); break;
1873  case kDeviceGetNumSerialPorts: outVal = ::NTV2DeviceGetNumSerialPorts (devID); break;
1874  case kDeviceGetNumTSIMuxers: { static const NTV2WidgetID s425MuxerIDs[] = {NTV2_Wgt425Mux1, NTV2_Wgt425Mux2,
1875  NTV2_Wgt425Mux3, NTV2_Wgt425Mux4};
1876  const ULWordSet wgtIDs(GetSupportedItems(kNTV2EnumsID_WidgetID));
1877  for (size_t ndx(0); ndx < sizeof(s425MuxerIDs)/sizeof(NTV2WidgetID); ndx++)
1878  if (wgtIDs.find(s425MuxerIDs[ndx]) != wgtIDs.end())
1879  outVal++;
1880  break;
1881  }
1882  case kDeviceGetNumUpConverters: outVal = ::NTV2DeviceGetNumUpConverters (devID); break;
1883  case kDeviceGetNumVideoChannels: outVal = ::NTV2DeviceGetNumVideoChannels (devID); break;
1884  case kDeviceGetNumVideoInputs: outVal = ::NTV2DeviceGetNumVideoInputs (devID); break;
1885  case kDeviceGetNumVideoOutputs: outVal = ::NTV2DeviceGetNumVideoOutputs (devID); break;
1886  case kDeviceGetPingLED: outVal = ::NTV2DeviceGetPingLED (devID); break;
1887  case kDeviceGetSPIFlashVersion: outVal = ::NTV2DeviceGetSPIFlashVersion (devID); break;
1888  case kDeviceGetTotalNumAudioSystems: outVal = ::NTV2DeviceGetNumAudioSystems(devID)
1889  + (IsSupported(kDeviceCanDoAudioMixer) ? 2 : 0); break;
1890  case kDeviceGetUFCVersion: outVal = ::NTV2DeviceGetUFCVersion (devID); break;
1891  default: return false; // Bad param
1892  }
1893  return true; // Successfully used old ::NTV2DeviceGetNum function
1894 
1895 } // GetNumericParam
1896 
1897 
1898 bool CNTV2DriverInterface::GetRegInfoForBoolParam (const NTV2BoolParamID inParamID, NTV2RegInfo & outRegInfo, bool & outFlipSense)
1899 {
1900  outRegInfo.MakeInvalid();
1901  outFlipSense = false;
1902  switch (inParamID)
1903  {
1904  case kDeviceCanDoAudioMixer: outRegInfo.Set(kRegGlobalControl2, 0, kRegMaskAudioMixerPresent, kRegShiftAudioMixerPresent); break;
1905  case kDeviceHasMultiRasterWidget: outRegInfo.Set(kRegMRSupport, 0, kRegMaskMRSupport, kRegShiftMRSupport); break;
1906  case kDeviceHasMicrophoneInput: outRegInfo.Set(kRegGlobalControl2, 0, kRegMaskIsDNXIV, kRegShiftIsDNXIV); break;
1907  case kDeviceAudioCanWaitForVBI: outRegInfo.Set(kRegCanDoStatus, 0, kRegMaskCanDoAudioWaitForVBI, kRegShiftCanDoAudioWaitForVBI); break;
1908  case kDeviceHasXptConnectROM: outRegInfo.Set(kRegCanDoStatus, 0, kRegMaskCanDoValidXptROM, kRegShiftCanDoValidXptROM); break;
1909 
1910 // BIT(2) IN kRegCanDoStatus NOT YET IN ALL KONA5, CORVID44/12G, KONAX FIRMWARE:
1911 // case kDeviceCanDoCustomHancInsertion: outRegInfo.Set(kRegCanDoStatus, 0, kRegMaskCanDoHancInsertion, kRegShiftCanDoHancInsertion); break;
1912 
1913  // kDeviceHasBreakoutBoard's sense is opposite of "BOBAbsent", so set outFlipSense 'true':
1914  case kDeviceHasBreakoutBoard: outRegInfo.Set(kRegBOBStatus, 0, kRegMaskBOBAbsent, kRegShiftBOBAbsent); outFlipSense = true; break;
1915 
1916  default: break;
1917  }
1918  return outRegInfo.IsValid();
1919 }
1920 
1921 
1922 bool CNTV2DriverInterface::GetRegInfoForNumericParam (const NTV2NumericParamID inParamID, NTV2RegInfo & outRegInfo)
1923 {
1924  outRegInfo.MakeInvalid();
1925  switch (inParamID)
1926  {
1927  case kDeviceGetNumMicInputs: outRegInfo.Set(kRegGlobalControl2, 0, kRegMaskIsDNXIV, kRegShiftIsDNXIV); break;
1928  default: break;
1929  }
1930  return outRegInfo.IsValid();
1931 }
1932 
1933 
1934 bool CNTV2DriverInterface::ControlDriverDebugMessages (NTV2_DriverDebugMessageSet msgSet, bool enable)
1935 { (void)msgSet; (void) enable;
1936  return false;
1937 }
NTV2DeviceCanDoConversionMode
bool NTV2DeviceCanDoConversionMode(const NTV2DeviceID inDeviceID, const NTV2ConversionMode inConversionMode)
Definition: ntv2devicefeatures.hpp:13810
NTV2StreamBuffer::mChannel
NTV2Channel mChannel
Stream channel.
Definition: ntv2publicinterface.h:9066
NTV2DeviceGetNumUpConverters
UWord NTV2DeviceGetNumUpConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13139
NTV2VideoFormatSet
std::set< NTV2VideoFormat > NTV2VideoFormatSet
A set of distinct NTV2VideoFormat values.
Definition: ntv2publicinterface.h:9148
NTV2_IS_VALID_NTV2ReferenceSource
#define NTV2_IS_VALID_NTV2ReferenceSource(__x__)
Definition: ntv2enums.h:1483
DEVICE_ID_IOXT
See Io XT.
Definition: ntv2enums.h:44
CNTV2DriverInterface::GetNumericParam
virtual bool GetNumericParam(const ULWord inParamID, ULWord &outValue)
Definition: ntv2driverinterface.cpp:1814
ntv2registersmb.h
Defines the KonaIP/IoIP registers.
CNTV2DriverInterface::ControlDriverDebugMessages
virtual bool ControlDriverDebugMessages(NTV2_DriverDebugMessageSet msgSet, bool enable)
Definition: ntv2driverinterface.cpp:1934
NTV2RegInfo
Everything needed to call CNTV2Card::ReadRegister or CNTV2Card::WriteRegister functions.
Definition: ntv2publicinterface.h:4046
NTV2InterruptEnumString
const char * NTV2InterruptEnumString(const unsigned inInterruptEnum)
Definition: ntv2debug.cpp:1175
BITSTREAM_READ_REGISTERS
#define BITSTREAM_READ_REGISTERS
Used in NTV2Bitstream to get status registers.
Definition: ntv2publicinterface.h:5741
NTV2DeviceCanDoLTC
bool NTV2DeviceCanDoLTC(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4186
NTV2StandardSetConstIter
NTV2StandardSet::const_iterator NTV2StandardSetConstIter
A handy const iterator for iterating over an NTV2StandardSet.
Definition: ntv2publicinterface.h:9160
NTV2StreamChannel::mFlags
ULWord mFlags
Action flags.
Definition: ntv2publicinterface.h:9007
kDeviceGetNumCrossConverters
The number of cross-converters on the device.
Definition: ntv2devicefeatures.h:197
NTV2FrameBufferFormatSet
std::set< NTV2FrameBufferFormat > NTV2FrameBufferFormatSet
A set of distinct NTV2FrameBufferFormat values.
Definition: ntv2publicinterface.h:9151
NTV2NumericParamID
enum _NTV2NumericParamID NTV2NumericParamID
Used with CNTV2DriverInterface::GetNumericParam to determine device capabilities. ...
CNTV2Bitfile::ParseHeaderFromBuffer
virtual std::string ParseHeaderFromBuffer(const uint8_t *inBitfileBuffer, const size_t inBufferSize)
Parse a bitfile header that&#39;s stored in a buffer.
Definition: ntv2bitfile.cpp:361
CNTV2DriverInterface::GetRegInfoForBoolParam
virtual bool GetRegInfoForBoolParam(const NTV2BoolParamID inParamID, NTV2RegInfo &outRegInfo, bool &outFlipSense)
Answers with the NTV2RegInfo of the register associated with the given boolean (i.e., "Can Do") device feature.
Definition: ntv2driverinterface.cpp:1898
CNTV2DriverInterface::AcquireStreamForApplicationWithReference
virtual bool AcquireStreamForApplicationWithReference(const ULWord inAppType, const int32_t inProcessID)
A reference-counted version of CNTV2DriverInterface::AcquireStreamForApplication useful for process g...
Definition: ntv2driverinterface.cpp:1084
NTV2DeviceCanDoGPIO
bool NTV2DeviceCanDoGPIO(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3120
BITFILE_INFO_STRUCT::dateStr
char dateStr[(16)]
Definition: ntv2publicinterface.h:4988
CNTV2DriverInterface::ResumeRecordRegisterWrites
virtual bool ResumeRecordRegisterWrites(void)
Resumes recording WriteRegister calls (after a prior call to PauseRecordRegisterWrites).
Definition: ntv2driverinterface.cpp:1449
kNTV2PluginRegInfoKey_LongName
#define kNTV2PluginRegInfoKey_LongName
Plugin long name.
Definition: ntv2nubaccess.h:76
DIDBGX
#define DIDBGX(__x__)
Definition: ntv2driverinterface.cpp:50
NTV2DeviceGetSupportedStandards
bool NTV2DeviceGetSupportedStandards(const NTV2DeviceID inDeviceID, NTV2StandardSet &outStandards)
Returns a set of distinct NTV2Standard values supported on the given device.
Definition: ntv2publicinterface.cpp:1364
kDeviceGetNumInputConverters
The number of input converter widgets on the device.
Definition: ntv2devicefeatures.h:208
CNTV2DriverInterface::IsSupported
virtual bool IsSupported(const NTV2BoolParamID inParamID)
Definition: ntv2driverinterface.h:419
kNTV2EnumsID_ScanGeometry
Identifies the NTV2ScanGeometry enumerated type.
Definition: ntv2devicefeatures.h:248
kDeviceGetNumTSIMuxers
The number of TSI muxers on the device. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:225
NTV2DeviceCanDoMultiLinkAudio
bool NTV2DeviceCanDoMultiLinkAudio(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4574
AJA_NTV2_SDK_BUILD_NUMBER
#define AJA_NTV2_SDK_BUILD_NUMBER
The SDK build number, an unsigned decimal integer.
Definition: ntv2version.h:16
kDeviceCanDo2KVideo
True if device can handle 2Kx1556 (film) video.
Definition: ntv2devicefeatures.h:40
CNTV2DeviceScanner::GetFirstDeviceWithID
static bool GetFirstDeviceWithID(const NTV2DeviceID inDeviceID, CNTV2Card &outDevice)
Rescans the host, and returns an open CNTV2Card instance for the first AJA device found on the host t...
Definition: ntv2devicescanner.cpp:186
NTV2OutputDestinationsConstIter
NTV2OutputDestinations::const_iterator NTV2OutputDestinationsConstIter
A handy const iterator for iterating over an NTV2OutputDestinations.
Definition: ntv2publicinterface.h:9166
kDeviceCanDoStereoOut
True if device supports 3D video output over dual-stream SDI.
Definition: ntv2devicefeatures.h:88
NTV2DeviceCanDoJ2K
bool NTV2DeviceCanDoJ2K(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4089
kConnectParamDevSerial
#define kConnectParamDevSerial
Device with this serial number.
Definition: ntv2nubaccess.h:28
kDeviceGetGenlockVersion
The version number of the device&#39;s genlock hardware/firmware. (New in SDK 17.6)
Definition: ntv2devicefeatures.h:227
kDeviceGetNumEmbeddedAudioInputChannels
The number of SDI-embedded input audio channels supported by the device.
Definition: ntv2devicefeatures.h:200
kDeviceCanDoMSI
True if device DMA hardware supports MSI (Message Signaled Interrupts).
Definition: ntv2devicefeatures.h:70
NTV2DeviceGetNumLTCInputs
UWord NTV2DeviceGetNumLTCInputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12371
kDeviceHasGenlockv3
True if device has version 3 genlock hardware and/or firmware. (Deprecate – use kDeviceGetGenlockVer...
Definition: ntv2devicefeatures.h:137
kDeviceHasSPIFlash
True if device has SPI flash hardware.
Definition: ntv2devicefeatures.h:99
NTV2Bitstream::mRegisters
ULWord mRegisters[16]
Register data.
Definition: ntv2publicinterface.h:8886
kDeviceCanDoAudio2Channels
True if audio system(s) support 2 or more audio channels.
Definition: ntv2devicefeatures.h:49
NTV2DeviceGetNum4kQuarterSizeConverters
UWord NTV2DeviceGetNum4kQuarterSizeConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10439
kDeviceGetNumAnalogVideoOutputs
The number of analog video outputs on the device.
Definition: ntv2devicefeatures.h:195
NTV2DeviceCanDoRP188
bool NTV2DeviceCanDoRP188(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5401
CNTV2AxiSpiFlash::DeviceSupported
static bool DeviceSupported(NTV2DeviceID deviceId)
Definition: ntv2spiinterface.cpp:249
DIDBG
#define DIDBG(__x__)
Definition: ntv2driverinterface.cpp:39
NTV2DeviceGetNumCrossConverters
UWord NTV2DeviceGetNumCrossConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11207
NTV2FrameRateSet
std::set< NTV2FrameRate > NTV2FrameRateSet
A set of distinct NTV2FrameRate values. New in SDK 17.0.
Definition: ntv2publicinterface.h:9168
kDeviceCanDoIsoConvert
True if device can do ISO conversion.
Definition: ntv2devicefeatures.h:67
kDeviceCanDoEnhancedCSC
True if device has enhanced CSCs.
Definition: ntv2devicefeatures.h:61
CNTV2DriverInterface::ReadFlashULWord
virtual bool ReadFlashULWord(const ULWord inAddress, ULWord &outValue, const ULWord inRetryCount=1000)
Definition: ntv2driverinterface.cpp:1047
NTV2_REFERENCE_FREERUN
Specifies the device&#39;s internal clock.
Definition: ntv2enums.h:1459
NTV2DeviceGetNumAnalogAudioOutputChannels
UWord NTV2DeviceGetNumAnalogAudioOutputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10823
NTV2RPCClientAPI::NTV2GetNumericParamRemote
virtual bool NTV2GetNumericParamRemote(const ULWord inParamID, ULWord &outValue)
Definition: ntv2nubaccess.cpp:2188
ntv2driverinterface.h
Declares the CNTV2DriverInterface base class.
NTV2RegInfo::registerMask
ULWord registerMask
My register mask value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4049
kDeviceGetNumReferenceVideoInputs
The number of external reference video inputs on the device.
Definition: ntv2devicefeatures.h:212
NTV2GetSupportedDevices
NTV2DeviceIDSet NTV2GetSupportedDevices(const NTV2DeviceKinds inKinds=NTV2_DEVICEKIND_ALL)
Returns an NTV2DeviceIDSet of devices supported by the SDK.
Definition: ntv2utils.cpp:7730
NTV2DeviceCanDo25GIP
bool NTV2DeviceCanDo25GIP(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:599
NTV2DeviceGetNum2022ChannelsSFP1
UWord NTV2DeviceGetNum2022ChannelsSFP1(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10151
kDeviceCanDo425Mux
True if the device supports SMPTE 425 mux control.
Definition: ntv2devicefeatures.h:43
NTV2DeviceCanThermostat
bool NTV2DeviceCanThermostat(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6854
CNTV2DriverInterface::CloseRemote
virtual bool CloseRemote(void)
Releases host resources associated with the remote/special device connection.
Definition: ntv2driverinterface.cpp:349
CNTV2DriverInterface::SetShareMode
static void SetShareMode(const bool inSharedMode)
Specifies if subsequent Open calls should open the device in shared mode or not.
Definition: ntv2driverinterface.cpp:63
CNTV2DriverInterface::IsLPSystemReady
virtual bool IsLPSystemReady(void)
Definition: ntv2driverinterface.cpp:1418
DEVICE_ID_KONAIP_2022
See KONA IP.
Definition: ntv2enums.h:71
gConstructCount
static uint32_t gConstructCount(0)
NTV2DeviceCanDoPCMControl
bool NTV2DeviceCanDoPCMControl(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4671
RP188_STRUCT
Definition: ntv2publicinterface.h:4210
NTV2DeviceCanDoDSKOpacity
bool NTV2DeviceCanDoDSKOpacity(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2539
DEVICE_ID_IOIP_2110
See Io IP.
Definition: ntv2enums.h:41
kDeviceGetNumVideoChannels
The number of video channels supported on the device.
Definition: ntv2devicefeatures.h:186
BITFILE_INFO_STRUCT::partNameStr
char partNameStr[(16)]
Definition: ntv2publicinterface.h:4994
NTV2StreamBuffer::mFlags
ULWord mFlags
Action flags.
Definition: ntv2publicinterface.h:9067
DEVICE_ID_KONA5_3DLUT
See KONA 5.
Definition: ntv2enums.h:55
CNTV2Card
I interrogate and control an AJA video/audio capture/playout device.
Definition: ntv2card.h:28
CNTV2DriverInterface::_boardNumber
UWord _boardNumber
My device index number.
Definition: ntv2driverinterface.h:681
kDeviceGetNumMixers
The number of mixer/keyer widgets on the device.
Definition: ntv2devicefeatures.h:210
NTV2FrameBufferFormat
NTV2FrameBufferFormat
Identifies a particular video frame buffer pixel format. See Device Frame Buffer Formats for details...
Definition: ntv2enums.h:219
kDeviceCanDoDVCProHD
True if device can squeeze/stretch between 1920x1080/1280x1080 and 1280x720/960x720.
Definition: ntv2devicefeatures.h:60
BIT
#define BIT(_x_)
Definition: ajatypes.h:578
kDeviceCanDo3GLevelConversion
True if device can do 3G level B to 3G level A conversion.
Definition: ntv2devicefeatures.h:41
kDeviceCanDoBreakoutBox
True if device supports an AJA breakout box.
Definition: ntv2devicefeatures.h:54
kNTV2EnumsID_DeviceID
Identifies the NTV2DeviceID enumerated type.
Definition: ntv2devicefeatures.h:243
kDeviceGetNumLTCOutputs
The number of analog LTC outputs on the device.
Definition: ntv2devicefeatures.h:220
RP188_STRUCT::High
ULWord High
Definition: ntv2publicinterface.h:4213
kDeviceGetNumAESAudioOutputChannels
The number of AES/EBU audio output channels on the device.
Definition: ntv2devicefeatures.h:191
PULWord
uint32_t * PULWord
Definition: ajatypes.h:224
DEVICE_ID_KONA5_OE8
See KONA 5.
Definition: ntv2enums.h:63
BITSTREAM_SUSPEND
#define BITSTREAM_SUSPEND
Used in peta to suspend board before bitstream load.
Definition: ntv2publicinterface.h:5742
debug.h
Declares the AJADebug class.
DEVICE_ID_KONALHEPLUS
See KONA LHe Plus.
Definition: ntv2enums.h:77
NTV2Dictionary::valueForKey
std::string valueForKey(const std::string &inKey) const
Definition: ntv2nubaccess.cpp:112
NTV2DeviceSpecParser::DeviceSpec
const std::string & DeviceSpec(void) const
Definition: ntv2nubaccess.h:173
NTV2InputVideoSelect
NTV2InputVideoSelect
Definition: ntv2enums.h:2296
kDeviceCanDoHDMIQuadRasterConversion
True if HDMI in/out supports square-division (quad) raster conversion. (New in SDK 17...
Definition: ntv2devicefeatures.h:153
NTV2DeviceGetNumFrameSyncs
UWord NTV2DeviceGetNumFrameSyncs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11879
DEVICE_ID_KONA5_OE1
See KONA 5.
Definition: ntv2enums.h:56
NTV2InputSourceSet
std::set< NTV2InputSource > NTV2InputSourceSet
A set of distinct NTV2InputSource values.
Definition: ntv2publicinterface.h:9162
DEVICE_ID_CORVID88
See Corvid 88.
Definition: ntv2enums.h:32
NEW_SELECT_RP188_RCVD
#define NEW_SELECT_RP188_RCVD
Definition: ntv2publicinterface.h:4250
NTV2DeviceGetActiveMemorySize
ULWord NTV2DeviceGetActiveMemorySize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9287
NTV2EnumsID
enum _NTV2EnumsID NTV2EnumsID
Identifies NTV2 enumerated types, used in CNTV2DriverInterface::GetSupportedItems.
kDeviceCanDoWarmBootFPGA
True if device can warm-boot to load updated firmware.
Definition: ntv2devicefeatures.h:131
CNTV2DriverInterface::GetIndexNumber
virtual UWord GetIndexNumber(void) const
Definition: ntv2driverinterface.h:114
CNTV2DriverInterface::IsDeviceReady
virtual bool IsDeviceReady(const bool inCheckValid=(0))
Definition: ntv2driverinterface.cpp:1361
NTV2DeviceCanDoHDMIOutStereo
bool NTV2DeviceCanDoHDMIOutStereo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3411
NTV2DeviceHasNTV4FrameStores
bool NTV2DeviceHasNTV4FrameStores(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7740
NTV2DeviceCanDoAnalogAudio
bool NTV2DeviceCanDoAnalogAudio(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1278
kNTV2PluginRegInfoKey_Copyright
#define kNTV2PluginRegInfoKey_Copyright
Plugin copyright notice.
Definition: ntv2nubaccess.h:78
kDeviceCanDoFrameStore1Display
True if device can display/output video from FrameStore 1.
Definition: ntv2devicefeatures.h:62
kDeviceGetNumAudioSystems
The number of independent Audio Systems on the device.
Definition: ntv2devicefeatures.h:196
CNTV2DriverInterface::setDeviceIndexNumber
void setDeviceIndexNumber(const UWord num)
Definition: ntv2driverinterface.cpp:1072
kNTV2EnumsID_AudioRate
Identifies the NTV2AudioRate enumerated type.
Definition: ntv2devicefeatures.h:255
kNTV2PluginRegInfoKey_Vendor
#define kNTV2PluginRegInfoKey_Vendor
Plugin vendor (manufacturer) name.
Definition: ntv2nubaccess.h:72
CNTV2DriverInterface::DriverGetBuildInformation
virtual bool DriverGetBuildInformation(BUILD_INFO_STRUCT &outBuildInfo)
Answers with the driver&#39;s build information.
Definition: ntv2driverinterface.cpp:846
kDeviceHasGenlockv2
True if device has version 2 genlock hardware and/or firmware. (Deprecate – use kDeviceGetGenlockVer...
Definition: ntv2devicefeatures.h:136
NTV2DeviceGetLUTVersion
ULWord NTV2DeviceGetLUTVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9767
NTV2_IS_VALID_INTERRUPT_ENUM
#define NTV2_IS_VALID_INTERRUPT_ENUM(__e__)
Definition: ntv2publicinterface.h:3878
NTV2DeviceSpecParser::Failed
bool Failed(void) const
Definition: ntv2nubaccess.h:178
DEVICE_ID_CORVID24
See Corvid 24.
Definition: ntv2enums.h:24
NTV2DeviceGetNumEmbeddedAudioOutputChannels
UWord NTV2DeviceGetNumEmbeddedAudioOutputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11687
NTV2DeviceCanDo425Mux
bool NTV2DeviceCanDo425Mux(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:890
kNTV2EnumsID_OutputDest
Identifies the NTV2OutputDest enumerated type.
Definition: ntv2devicefeatures.h:252
NTV2BoolParamID
enum _NTV2BoolParamID NTV2BoolParamID
Used with CNTV2DriverInterface::GetBoolParam to determine device capabilities.
NTV2DeviceCanDoMultiFormat
bool NTV2DeviceCanDoMultiFormat(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4477
NTV2DeviceCanDo12GSDI
bool NTV2DeviceCanDo12GSDI(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:405
kDeviceCanReportFailSafeLoaded
True if device can report if its "fail-safe" firmware is loaded/running.
Definition: ntv2devicefeatures.h:132
NTV2DeviceHasSPIFlash
bool NTV2DeviceHasSPIFlash(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8418
kDeviceIsExternalToHost
True if device connects to the host with a cable.
Definition: ntv2devicefeatures.h:106
DIFAIL
#define DIFAIL(__x__)
Definition: ntv2driverinterface.cpp:35
NTV2DeviceCanDoEnhancedCSC
bool NTV2DeviceCanDoEnhancedCSC(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2830
NTV2DeviceCanDoStereoOut
bool NTV2DeviceCanDoStereoOut(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5886
NTV2Buffer::GetByteCount
ULWord GetByteCount(void) const
Definition: ntv2publicinterface.h:6292
NTV2DeviceGetNumDownConverters
UWord NTV2DeviceGetNumDownConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11495
kNTV2PluginRegInfoKey_ShortName
#define kNTV2PluginRegInfoKey_ShortName
Plugin short name.
Definition: ntv2nubaccess.h:75
kDeviceCanDoPCMDetection
True if device can detect which audio channel pairs are not carrying PCM (Pulse Code Modulation) audi...
Definition: ntv2devicefeatures.h:73
NTV2DeviceGetNumSerialPorts
UWord NTV2DeviceGetNumSerialPorts(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13043
CNTV2DriverInterface::Close
virtual bool Close(void)
Closes me, releasing host resources that may have been allocated in a previous Open call...
Definition: ntv2driverinterface.cpp:243
CNTV2DriverInterface::ConfigureInterrupt
virtual bool ConfigureInterrupt(const bool bEnable, const INTERRUPT_ENUMS eInterruptType)
Definition: ntv2driverinterface.cpp:400
CNTV2DriverInterface::FinishOpen
virtual void FinishOpen(void)
Initializes my member variables after a successful Open.
Definition: ntv2driverinterface.cpp:948
CNTV2DriverInterface::GetBoolParam
virtual bool GetBoolParam(const ULWord inParamID, ULWord &outValue)
Definition: ntv2driverinterface.cpp:1635
SAREK_REGS
#define SAREK_REGS
Definition: ntv2registersmb.h:54
LWord
int32_t LWord
Definition: ajatypes.h:222
NTV2DeviceSpecParser
One-stop shop for parsing device specifications. (New in SDK 16.3) I do very little in the way of val...
Definition: ntv2nubaccess.h:168
NTV2DeviceCanDoProRes
bool NTV2DeviceCanDoProRes(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5072
systemtime.h
Declares the AJATime class.
kDeviceHasHEVCM31
True if device has an HEVC M31 encoder.
Definition: ntv2devicefeatures.h:112
CNTV2DriverInterface::IsRecordingRegisterWrites
virtual bool IsRecordingRegisterWrites(void) const
Definition: ntv2driverinterface.cpp:1458
BITFILE_INFO_STRUCT::designNameStr
char designNameStr[(100)]
Definition: ntv2publicinterface.h:4990
CNTV2DriverInterface::Open
virtual bool Open(const UWord inDeviceIndex)
Opens a local/physical AJA device so it can be monitored/controlled.
Definition: ntv2driverinterface.cpp:133
kDeviceHasLEDAudioMeters
True if device has LED audio meters.
Definition: ntv2devicefeatures.h:139
NTV2RPCClientAPI::NTV2GetSupportedRemote
virtual bool NTV2GetSupportedRemote(const ULWord inEnumsID, ULWordSet &outSupported)
Definition: ntv2nubaccess.cpp:2194
NTV2_FOURCC
#define NTV2_FOURCC(_a_, _b_, _c_, _d_)
Definition: ntv2publicinterface.h:5623
NTV2DeviceGetNumCSCs
UWord NTV2DeviceGetNumCSCs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11303
if
if(!(riid==IID_IUnknown) &&!(riid==IID_IClassFactory))
Definition: dllentry.cpp:196
kDeviceGetLUTVersion
The version number of the LUT(s) on the device.
Definition: ntv2devicefeatures.h:181
kNTV2EnumsID_VideoFormat
Identifies the NTV2VideoFormat enumerated type.
Definition: ntv2devicefeatures.h:249
DEVICE_ID_KONA4
See KONA 4 (Quad Mode).
Definition: ntv2enums.h:48
ntv2spiinterface.h
Declares the CNTV2SpiFlash and CNTV2AxiSpiFlash classes.
kDeviceCanDoIP
True if device has SFP connectors.
Definition: ntv2devicefeatures.h:129
BITSTREAM_RESUME
#define BITSTREAM_RESUME
Used in peta to resume board after bitstream load.
Definition: ntv2publicinterface.h:5743
NTV2_TCINDEX_DEFAULT
The "default" timecode (mostly used by the AJA "Retail" service and Control Panel) ...
Definition: ntv2enums.h:3953
PACKAGE_INFO_STRUCT::time
std::string time
Definition: ntv2driverinterface.h:53
CNTV2DriverInterface::GetShareMode
static bool GetShareMode(void)
Definition: ntv2driverinterface.cpp:64
kNTV2EnumsID_Channel
Identifies the NTV2Channel enumerated type.
Definition: ntv2devicefeatures.h:253
kDeviceNeedsRoutingSetup
True if device widget routing can be queried or changed.
Definition: ntv2devicefeatures.h:109
kDeviceCanDoVideoProcessing
True if device can do video processing.
Definition: ntv2devicefeatures.h:90
NTV2RegInfo::MakeInvalid
void MakeInvalid(void)
Invalidates me, setting my register number, value, mask and shift values to 0xFFFFFFFF.
Definition: ntv2publicinterface.h:4081
kNTV2EnumsID_InputSource
Identifies the NTV2InputSource enumerated type.
Definition: ntv2devicefeatures.h:251
NTV2MailBuffer::mDelay
ULWord mDelay
Trial delay (us)
Definition: ntv2publicinterface.h:9122
CNTV2DriverInterface::ReleaseStreamForApplication
virtual bool ReleaseStreamForApplication(const ULWord inAppType, const int32_t inProcessID)
Releases exclusive use of the AJA device for the given process, permitting other processes to acquire...
Definition: ntv2driverinterface.cpp:1183
kDeviceCanDoRGBLevelAConversion
True if the device can do RGB over 3G Level A.
Definition: ntv2devicefeatures.h:42
std
Definition: json.hpp:5362
NTV2_DriverDebugMessageSet
NTV2_DriverDebugMessageSet
Definition: ntv2enums.h:3829
DEVICE_ID_KONA5_OE3
See KONA 5.
Definition: ntv2enums.h:58
NTV2OutputDestinations
std::set< NTV2OutputDestination > NTV2OutputDestinations
A set of distinct NTV2OutputDestination values.
Definition: ntv2publicinterface.h:9165
CNTV2DriverInterface::SetOverlappedMode
static void SetOverlappedMode(const bool inOverlapMode)
Specifies if the next Open call should try to open the device in overlapped mode or not...
Definition: ntv2driverinterface.cpp:66
CNTV2AxiSpiFlash::Offset
virtual uint32_t Offset(SpiFlashSection sectionID=SPI_FLASH_SECTION_TOTAL)
Definition: ntv2spiinterface.cpp:510
kDeviceGetMaxTransferCount
The maximum number of 32-bit words that the DMA engine can move at a time on the device.
Definition: ntv2devicefeatures.h:184
kDeviceCanDoQREZ
True if device can handle QRez.
Definition: ntv2devicefeatures.h:79
false
#define false
Definition: ntv2devicefeatures.h:25
NTV2DeviceGetNumAnalogVideoInputs
UWord NTV2DeviceGetNumAnalogVideoInputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10919
kAgentAppFcc
const uint32_t kAgentAppFcc(((((uint32_t)( 'A'))<< 24)|(((uint32_t)( 'j'))<< 16)|(((uint32_t)( 'a'))<< 8)|(((uint32_t)( 'A'))<< 0)))
NTV2DeviceGetGenlockVersion
UWord NTV2DeviceGetGenlockVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9575
NTV2DeviceCanDoIsoConvert
bool NTV2DeviceCanDoIsoConvert(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3992
DEVICE_ID_KONA1
See KONA 1.
Definition: ntv2enums.h:45
kRegSarekMBUptime
#define kRegSarekMBUptime
Definition: ntv2registersmb.h:77
AJA_NTV2_SDK_VERSION_POINT
#define AJA_NTV2_SDK_VERSION_POINT
The SDK "point" release version, an unsigned decimal integer.
Definition: ntv2version.h:15
ULWord
uint32_t ULWord
Definition: ajatypes.h:223
kDeviceGetNumDMAEngines
The number of DMA engines on the device.
Definition: ntv2devicefeatures.h:185
CNTV2DriverInterface::DmaTransfer
virtual bool DmaTransfer(const NTV2DMAEngine inDMAEngine, const bool inIsRead, const ULWord inFrameNumber, ULWord *pFrameBuffer, const ULWord inCardOffsetBytes, const ULWord inTotalByteCount, const bool inSynchronous=(!(0)))
Transfers data between the AJA device and the host. This function will block and not return to the ca...
Definition: ntv2driverinterface.cpp:524
CNTV2DriverInterface::StartRecordRegisterWrites
virtual bool StartRecordRegisterWrites(const bool inSkipActualWrites=(0))
Starts recording all WriteRegister calls.
Definition: ntv2driverinterface.cpp:1438
DEVICE_ID_KONA5_OE10
See KONA 5.
Definition: ntv2enums.h:65
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They&#39;re also commonly use...
Definition: ntv2enums.h:1357
BITSTREAM_FRAGMENT
#define BITSTREAM_FRAGMENT
Used in NTV2Bitstream to indicate bitstream is a fragment.
Definition: ntv2publicinterface.h:5737
CNTV2DriverInterface::SetInterruptEventCount
virtual bool SetInterruptEventCount(const INTERRUPT_ENUMS inEventCode, const ULWord inCount)
Resets my interrupt event tally for the given interrupt type. (This is my count of the number of succ...
Definition: ntv2driverinterface.cpp:378
CNTV2DriverInterface::ConnectParams
virtual NTV2Dictionary ConnectParams(void) const
Definition: ntv2driverinterface.cpp:1232
HANDLE
short HANDLE
Definition: ajatypes.h:285
kDeviceCanDoAudioDelay
True if Audio System(s) support an adjustable delay.
Definition: ntv2devicefeatures.h:53
kDeviceCanDoBreakoutBoard
True if device supports an AJA breakout board. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:144
ntv2nubaccess.h
Declares NTV2 "nub" client functions.
NTV2DeviceCanDoMSI
bool NTV2DeviceCanDoMSI(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4380
DEVICE_ID_IO4KPLUS
See Io 4K Plus.
Definition: ntv2enums.h:37
gSharedMode
static bool gSharedMode((0))
NTV2Dictionary::hasKey
bool hasKey(const std::string &inKey) const
Definition: ntv2nubaccess.h:120
kConnectParamDevModel
#define kConnectParamDevModel
First device of this model (e.g. &#39;kona4&#39;)
Definition: ntv2nubaccess.h:29
NTV2DriverVersionDecode_Major
#define NTV2DriverVersionDecode_Major(__vers__)
Definition: ntv2publicinterface.h:5554
NTV2FrameRateSetConstIter
NTV2FrameRateSet::const_iterator NTV2FrameRateSetConstIter
A handy const iterator for iterating over an NTV2FrameRateSet.
Definition: ntv2publicinterface.h:9169
CNTV2DriverInterface::BitstreamLoad
virtual bool BitstreamLoad(const bool inSuspend, const bool inResume)
Definition: ntv2driverinterface.cpp:895
NTV2StandardSet
std::set< NTV2Standard > NTV2StandardSet
A set of distinct NTV2Standard values.
Definition: ntv2publicinterface.h:9159
DEVICE_ID_CORVID44
See Corvid 44.
Definition: ntv2enums.h:26
kDeviceCanDoMultiLinkAudio
True if device supports grouped audio system control.
Definition: ntv2devicefeatures.h:130
NTV2DriverVersionDecode_Point
#define NTV2DriverVersionDecode_Point(__vers__)
Definition: ntv2publicinterface.h:5556
NTV2DeviceNeedsRoutingSetup
bool NTV2DeviceNeedsRoutingSetup(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9094
NTV2_ASSERT
#define NTV2_ASSERT(_expr_)
Definition: ajatypes.h:476
kDeviceGetNumVideoOutputs
The number of SDI video outputs on the device.
Definition: ntv2devicefeatures.h:216
NTV2RPCClientAPI::NTV2DMATransferRemote
virtual bool NTV2DMATransferRemote(const NTV2DMAEngine inDMAEngine, const bool inIsRead, const ULWord inFrameNumber, NTV2Buffer &inOutBuffer, const ULWord inCardOffsetBytes, const ULWord inNumSegments, const ULWord inSegmentHostPitch, const ULWord inSegmentCardPitch, const bool inSynchronous)
Definition: ntv2nubaccess.cpp:2167
kConnectParamDevID
#define kConnectParamDevID
First device having this ID (e.g. &#39;0x10518400&#39;)
Definition: ntv2nubaccess.h:30
NTV2_MODE_OUTPUT
Output (playout, display) mode, which reads from device SDRAM.
Definition: ntv2enums.h:1242
DEVICE_ID_KONA3GQUAD
See KONA 3G (Quad Mode).
Definition: ntv2enums.h:47
kDeviceCanDoStreamingDMA
True if device supports streaming DMA. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:155
NTV2DeviceSoftwareCanChangeFrameBufferSize
bool NTV2DeviceSoftwareCanChangeFrameBufferSize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9190
NTV2DeviceIs64Bit
bool NTV2DeviceIs64Bit(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8707
NTV2DeviceSpecParser::IsLocalDevice
bool IsLocalDevice(void) const
Definition: ntv2nubaccess.h:181
NTV2DeviceCanDoFrameStore1Display
bool NTV2DeviceCanDoFrameStore1Display(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3023
NTV2GeometrySetConstIter
NTV2GeometrySet::const_iterator NTV2GeometrySetConstIter
A handy const iterator for iterating over an NTV2GeometrySet.
Definition: ntv2publicinterface.h:9157
NTV2PixelFormat
NTV2FrameBufferFormat NTV2PixelFormat
An alias for NTV2FrameBufferFormat.
Definition: ntv2enums.h:260
CNTV2Bitfile::GetProgramStreamLength
virtual size_t GetProgramStreamLength(void) const
Definition: ntv2bitfile.h:210
CNTV2DriverInterface::AcquireStreamForApplication
virtual bool AcquireStreamForApplication(const ULWord inAppType, const int32_t inProcessID)
Reserves exclusive use of the AJA device for a given process, preventing other processes on the host ...
Definition: ntv2driverinterface.cpp:1146
kDeviceCanDoAudioOutput
True if device has any audio output capability (SDI, HDMI or analog) (New in SDK 17.1)
Definition: ntv2devicefeatures.h:150
kDeviceGetTotalNumAudioSystems
The total number of audio systems on the device, including host audio and mixer audio systems...
Definition: ntv2devicefeatures.h:223
NTV2DeviceHasSPIFlashSerial
bool NTV2DeviceHasSPIFlashSerial(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8514
NTV2RPCClientAPI::NTV2GetBoolParamRemote
virtual bool NTV2GetBoolParamRemote(const ULWord inParamID, ULWord &outValue)
Definition: ntv2nubaccess.cpp:2182
CNTV2DriverInterface::IsRemote
virtual bool IsRemote(void) const
Definition: ntv2driverinterface.h:568
BITFILE_INFO_STRUCT::structSize
ULWord structSize
Definition: ntv2publicinterface.h:4985
DEVICE_ID_KONA5_OE11
See KONA 5.
Definition: ntv2enums.h:66
NTV2DeviceCanReportFailSafeLoaded
bool NTV2DeviceCanReportFailSafeLoaded(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6564
NTV2DeviceHasBiDirectionalAnalogAudio
bool NTV2DeviceHasBiDirectionalAnalogAudio(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7048
kDeviceIs64Bit
True if device is 64-bit addressable.
Definition: ntv2devicefeatures.h:104
kDeviceCanDoLTCInOnRefPort
True if device can read LTC (Linear TimeCode) from its reference input.
Definition: ntv2devicefeatures.h:69
DEVICE_ID_TTAP
See T-TAP.
Definition: ntv2enums.h:93
BITFILE_INFO_STRUCT::whichFPGA
NTV2XilinxFPGA whichFPGA
Definition: ntv2publicinterface.h:4995
NTV2TCIndex
NTV2TCIndex
These enum values are indexes into the capture/playout AutoCirculate timecode arrays.
Definition: ntv2enums.h:3951
kDeviceCanDoPCMControl
True if device can mark specific audio channel pairs as not carrying PCM (Pulse Code Modulation) audi...
Definition: ntv2devicefeatures.h:72
NTV2_REFERENCE_EXTERNAL
Specifies the External Reference connector.
Definition: ntv2enums.h:1456
kDeviceHasBiDirectionalSDI
True if device SDI connectors are bi-directional.
Definition: ntv2devicefeatures.h:93
CNTV2DeviceScanner::GetFirstDeviceWithName
static bool GetFirstDeviceWithName(const std::string &inNameSubString, CNTV2Card &outDevice)
Rescans the host, and returns an open CNTV2Card instance for the first AJA device whose device identi...
Definition: ntv2devicescanner.cpp:204
NTV2GetRegisters::GetRegisterValues
bool GetRegisterValues(NTV2RegisterValueMap &outValues) const
Returns an NTV2RegisterValueMap built from my mOutGoodRegisters and mOutValues fields.
Definition: ntv2publicinterface.cpp:3300
CNTV2DriverInterface::GetStreamingApplication
virtual bool GetStreamingApplication(ULWord &outAppType, int32_t &outProcessID)
Answers with the four-CC type and process ID of the application that currently "owns" the AJA device ...
Definition: ntv2driverinterface.cpp:1200
kNTV2EnumsID_AudioSource
Identifies the NTV2AudioSource enumerated type.
Definition: ntv2devicefeatures.h:256
NTV2DeviceGetNumHDMIVideoOutputs
UWord NTV2DeviceGetNumHDMIVideoOutputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12179
CNTV2DriverInterface
I&#39;m the base class that undergirds the platform-specific derived classes (from which CNTV2Card is ult...
Definition: ntv2driverinterface.h:60
NTV2RPCClientAPI
An object that can connect to, and operate remote or fake devices. I have three general API groups: ...
Definition: ntv2nubaccess.h:290
kDeviceCanDoRGBPlusAlphaOut
True if device has CSCs capable of splitting the key (alpha) and YCbCr (fill) from RGB frame buffers ...
Definition: ntv2devicefeatures.h:82
kDeviceGetUFCVersion
The version number of the UFC on the device.
Definition: ntv2devicefeatures.h:188
kDeviceCanDoProgrammableCSC
True if device has at least one programmable color space converter widget.
Definition: ntv2devicefeatures.h:76
DEVICE_ID_KONA5_OE7
See KONA 5.
Definition: ntv2enums.h:62
kDeviceCanDoStereoIn
True if device supports 3D video input over dual-stream SDI.
Definition: ntv2devicefeatures.h:87
kDeviceCanDoPIO
True if device supports Programmed I/O.
Definition: ntv2devicefeatures.h:74
NTV2DeviceCanDoInputTCIndex
bool NTV2DeviceCanDoInputTCIndex(const NTV2DeviceID inDeviceID, const NTV2TCIndex inTCIndex)
Definition: ntv2devicefeatures.cpp:1043
kDeviceROMHasBankSelect
True if device SPIFlash ROM is bank-selected. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:157
CNTV2Bitfile::GetDesignName
virtual std::string GetDesignName(void) const
Definition: ntv2bitfile.h:139
kDeviceGetMaxRegisterNumber
The highest register number for the device.
Definition: ntv2devicefeatures.h:183
kNTV2EnumsID_RefSource
Identifies the NTV2RefSource enumerated type.
Definition: ntv2devicefeatures.h:254
NTV2RegInfo::registerValue
ULWord registerValue
My register value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4048
kDeviceHasSPIv2
Use kDeviceGetSPIVersion instead.
Definition: ntv2devicefeatures.h:101
NTV2DeviceGetNumInputConverters
UWord NTV2DeviceGetNumInputConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12275
CNTV2DriverInterface::GetLegalSchemeNames
static NTV2StringList GetLegalSchemeNames(void)
Definition: ntv2driverinterface.cpp:55
NTV2DeviceID
NTV2DeviceID
Identifies a specific AJA NTV2 device model number. The NTV2DeviceID is actually the PROM part number...
Definition: ntv2enums.h:20
CNTV2DriverInterface::SetStreamingApplication
virtual bool SetStreamingApplication(const ULWord inAppType, const int32_t inProcessID)
Sets the four-CC type and process ID of the application that should "own" the AJA device (i...
Definition: ntv2driverinterface.cpp:1193
DEVICE_ID_KONA5_OE2
See KONA 5.
Definition: ntv2enums.h:57
NTV2RegInfo::registerNumber
ULWord registerNumber
My register number to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4047
kDeviceGetPingLED
The highest bit number of the LED bits in the Global Control Register on the device.
Definition: ntv2devicefeatures.h:187
NTV2DeviceCanDoDualLink
bool NTV2DeviceCanDoDualLink(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2636
CNTV2DriverInterface::_boardID
NTV2DeviceID _boardID
My cached device ID.
Definition: ntv2driverinterface.h:682
NTV2DeviceCanDoWidget
bool NTV2DeviceCanDoWidget(const NTV2DeviceID inDeviceID, const NTV2WidgetID inWidgetID)
Definition: ntv2devicefeatures.hpp:33881
ntv2enums.h
Enumerations for controlling NTV2 devices.
CNTV2DriverInterface::PauseRecordRegisterWrites
virtual bool PauseRecordRegisterWrites(void)
Pauses recording WriteRegister calls.
Definition: ntv2driverinterface.cpp:1471
NTV2RegInfo::Set
void Set(const ULWord inRegNum, const ULWord inValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Sets me from the given parameters.
Definition: ntv2publicinterface.h:4075
kDeviceGetNumFrameStores
The number of FrameStores on the device.
Definition: ntv2devicefeatures.h:202
Word
int16_t Word
Definition: ajatypes.h:220
NTV2RPCClientAPI::NTV2Disconnect
virtual bool NTV2Disconnect(void)
Disconnects me from the remote/fake host, closing the connection.
Definition: ntv2nubaccess.cpp:2111
DEVICE_ID_IO4K
See Io 4K (Quad Mode).
Definition: ntv2enums.h:36
kDeviceCanDoQuarterExpand
True if device can handle quarter-sized frames (pixel-halving and line-halving during input...
Definition: ntv2devicefeatures.h:80
CNTV2DriverInterface::IsOpen
virtual bool IsOpen(void) const
Definition: ntv2driverinterface.h:115
CNTV2DriverInterface::OpenLocalPhysical
virtual bool OpenLocalPhysical(const UWord inDeviceIndex)
Opens the local/physical device connection.
Definition: ntv2driverinterface.cpp:263
kDeviceHasSDIRelays
True if device has bypass relays on its SDI connectors.
Definition: ntv2devicefeatures.h:98
DEVICE_ID_KONALHI
See KONA LHi.
Definition: ntv2enums.h:78
DEVICE_ID_NOTFOUND
Invalid or "not found".
Definition: ntv2enums.h:98
CNTV2DriverInterface::_boardOpened
bool _boardOpened
True if I&#39;m open and connected to the device.
Definition: ntv2driverinterface.h:683
AJA_NTV2_SDK_VERSION_MAJOR
#define AJA_NTV2_SDK_VERSION_MAJOR
The SDK major version number, an unsigned decimal integer.
Definition: ntv2version.h:13
DEVICE_ID_CORVIDHBR
See Corvid HB-R.
Definition: ntv2enums.h:34
NTV2DeviceIDSetConstIter
NTV2DeviceIDSet::const_iterator NTV2DeviceIDSetConstIter
A convenient const iterator for NTV2DeviceIDSet.
Definition: ntv2utils.h:1046
PACKAGE_INFO_STRUCT::packageNumber
std::string packageNumber
Definition: ntv2driverinterface.h:51
NTV2DeviceCanDoHDV
bool NTV2DeviceCanDoHDV(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3508
CNTV2Bitfile::GetLastError
virtual const std::string & GetLastError(void) const
Definition: ntv2bitfile.h:149
NTV2ReferenceSource
NTV2ReferenceSource
These enum values identify a specific source for the device&#39;s (output) reference clock.
Definition: ntv2enums.h:1454
BITFILE_INFO_STRUCT::bitFileType
ULWord bitFileType
Definition: ntv2publicinterface.h:4992
kRegSarekIfVersion
#define kRegSarekIfVersion
Definition: ntv2registersmb.h:85
CNTV2DriverInterface::ReadRegisters
virtual bool ReadRegisters(NTV2RegisterReads &inOutValues)
Reads the register(s) specified by the given NTV2RegInfo sequence.
Definition: ntv2driverinterface.cpp:456
CNTV2DriverInterface::BumpEventCount
virtual void BumpEventCount(const INTERRUPT_ENUMS eInterruptType)
Atomically increments the event count tally for the given interrupt type.
Definition: ntv2driverinterface.cpp:1353
CNTV2DeviceScanner::GetDeviceWithSerial
static bool GetDeviceWithSerial(const std::string &inSerialNumber, CNTV2Card &outDevice)
Rescans the host, and returns an open CNTV2Card instance for the first AJA device whose serial number...
NTV2VideoFormatSetConstIter
NTV2VideoFormatSet::const_iterator NTV2VideoFormatSetConstIter
A handy const iterator for iterating over an NTV2VideoFormatSet.
Definition: ntv2publicinterface.h:9149
NTV2DeviceGetNumFrameStores
UWord NTV2DeviceGetNumFrameStores(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11783
NTV2DeviceCanDoAudio96K
bool NTV2DeviceCanDoAudio96K(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1666
NTV2RPCClientAPI::NTV2MessageRemote
virtual bool NTV2MessageRemote(NTV2_HEADER *pInMessage)
Definition: ntv2nubaccess.cpp:2177
kDeviceCanDoHDV
True if device can squeeze/stretch between 1920x1080 and 1440x1080.
Definition: ntv2devicefeatures.h:65
CNTV2Bitfile::Open
virtual bool Open(const std::string &inBitfilePath)
Opens the bitfile at the given path, then parses its header.
Definition: ntv2bitfile.cpp:322
kDeviceCanDoJ2K
True if device supports JPEG 2000 codec.
Definition: ntv2devicefeatures.h:116
NTV2StreamChannel::mChannel
NTV2Channel mChannel
Stream channel.
Definition: ntv2publicinterface.h:9006
NTV2DMAEngine
NTV2DMAEngine
Definition: ntv2enums.h:1856
BITSTREAM_RESET_CONFIG
#define BITSTREAM_RESET_CONFIG
Used in NTV2Bitstream to reset config.
Definition: ntv2publicinterface.h:5739
AJA_NULL
#define AJA_NULL
Definition: ajatypes.h:167
CNTV2Bitfile::GetTime
virtual const std::string & GetTime(void) const
Definition: ntv2bitfile.h:134
kDeviceHasBreakoutBoard
True if device has attached breakout board. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:145
kDeviceHasBracketLED
True if device has LED(s) on the card bracket. (New in SDK 18.0)
Definition: ntv2devicefeatures.h:160
NTV2DeviceCanDoHFRRGB
bool NTV2DeviceCanDoHFRRGB(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3702
NTV2DeviceGetDownConverterDelay
UWord NTV2DeviceGetDownConverterDelay(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9479
CNTV2DriverInterface::ReadRegister
virtual bool ReadRegister(const ULWord inRegNum, ULWord &outValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Reads all or part of the 32-bit contents of a specific register (real or virtual) on the AJA device...
Definition: ntv2driverinterface.cpp:445
kDeviceCanDoPlayback
True if device has any SDI, HDMI or analog video outputs.
Definition: ntv2devicefeatures.h:75
kDeviceGetNumUpConverters
The number of up-converters on the device.
Definition: ntv2devicefeatures.h:214
DEVICE_ID_KONA5_OE6
See KONA 5.
Definition: ntv2enums.h:61
kDeviceCanDoAudioInput
True if device has any audio input capability (SDI, HDMI or analog) (New in SDK 17.1)
Definition: ntv2devicefeatures.h:149
DEVICE_ID_KONA5_OE12
See KONA 5.
Definition: ntv2enums.h:67
kDeviceHasHeadphoneJack
True if device has a headphone jack.
Definition: ntv2devicefeatures.h:138
NTV2DeviceHasPWMFanControl
bool NTV2DeviceHasPWMFanControl(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8031
ajatypes.h
Declares the most fundamental data types used by NTV2. Since Windows NT was the first principal devel...
NTV2WidgetIDSet
std::set< NTV2WidgetID > NTV2WidgetIDSet
A collection of distinct NTV2WidgetID values.
Definition: ntv2signalrouter.h:32
DEVICE_ID_CORVID44_PLNR
See Corvid 44 12G.
Definition: ntv2enums.h:31
CNTV2DriverInterface::BitstreamReset
virtual bool BitstreamReset(const bool inConfiguration, const bool inInterface)
Definition: ntv2driverinterface.cpp:870
BITFILE_INFO_STRUCT
Definition: ntv2publicinterface.h:4982
NTV2ULWordVector
std::vector< ULWord > NTV2ULWordVector
An ordered sequence of ULWords.
Definition: ntv2publicinterface.h:3909
CNTV2DriverInterface::CloseLocalPhysical
virtual bool CloseLocalPhysical(void)
Releases host resources associated with the local/physical device connection.
Definition: ntv2driverinterface.cpp:274
ntv2version.h
Defines for the NTV2 SDK version number, used by ajantv2/includes/ntv2enums.h. See the ajantv2/includ...
INTERRUPT_ENUMS
enum _INTERRUPT_ENUMS_ INTERRUPT_ENUMS
kDeviceCanDo25GIP
True if device has 25Gbps SFPs. (New in SDK 18.0)
Definition: ntv2devicefeatures.h:161
AJATime::Sleep
static void Sleep(const int32_t inMilliseconds)
Suspends execution of the current thread for a given number of milliseconds.
Definition: systemtime.cpp:284
DEVICE_ID_KONA5_2X4K
See KONA 5.
Definition: ntv2enums.h:54
NTV2DeviceIsSupported
bool NTV2DeviceIsSupported(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8997
kDeviceCanDoProgrammableRS422
True if device has at least one RS-422 serial port, and it (they) can be programmed (for baud rate...
Definition: ntv2devicefeatures.h:77
NTV2RegInfo::IsValid
bool IsValid(void) const
Definition: ntv2publicinterface.h:4088
kDeviceHasAudioMonitorRCAJacks
True if device has a pair of unbalanced RCA audio monitor output connectors.
Definition: ntv2devicefeatures.h:134
kNTV2EnumsID_Standard
Identifies the NTV2Standard enumerated type.
Definition: ntv2devicefeatures.h:244
NTV2DeviceGetMaxTransferCount
ULWord NTV2DeviceGetMaxTransferCount(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10055
kDeviceCanDoStackedAudio
True if device uses a "stacked" arrangement of its audio buffers.
Definition: ntv2devicefeatures.h:86
retVal
else retVal
Definition: ntv2vcam.cpp:1100
BITFILE_INFO_STRUCT::numBytes
ULWord numBytes
Definition: ntv2publicinterface.h:4987
ULWordSet
std::set< ULWord > ULWordSet
A collection of unique ULWord (uint32_t) values.
Definition: ntv2publicinterface.h:54
DIWARN
#define DIWARN(__x__)
Definition: ntv2driverinterface.cpp:36
CNTV2DriverInterface::mRecordRegWrites
bool mRecordRegWrites
True if recording; otherwise false when not recording.
Definition: ntv2driverinterface.h:685
NTV2StringList
std::vector< std::string > NTV2StringList
Definition: ntv2utils.h:1155
BITSTREAM_MCAP_DATA
#define BITSTREAM_MCAP_DATA
MCAP data register.
Definition: ntv2publicinterface.h:5752
CNTV2DriverInterface::GetRegInfoForNumericParam
virtual bool GetRegInfoForNumericParam(const NTV2NumericParamID inParamID, NTV2RegInfo &outRegInfo)
Answers with the NTV2RegInfo of the register associated with the given numeric (i.e., "Get Num") device feature.
Definition: ntv2driverinterface.cpp:1922
PACKAGE_INFO_STRUCT::date
std::string date
Definition: ntv2driverinterface.h:52
DEVICE_ID_SOFTWARE
Software device that doesn&#39;t emulate one of the above devices.
Definition: ntv2enums.h:83
kNTV2PluginRegInfoKey_Description
#define kNTV2PluginRegInfoKey_Description
Brief plugin description.
Definition: ntv2nubaccess.h:77
kRegSarekMBState
#define kRegSarekMBState
Definition: ntv2registersmb.h:78
NTV2_HEADER
All new NTV2 structs start with this common header.
Definition: ntv2publicinterface.h:7198
BUILD_INFO_STRUCT
Definition: ntv2publicinterface.h:5097
NTV2RegisterReads
NTV2RegWrites NTV2RegisterReads
Definition: ntv2publicinterface.h:4141
CNTV2DriverInterface::mRegWritesLock
AJALock mRegWritesLock
Guard mutex for mRegWrites.
Definition: ntv2driverinterface.h:694
NTV2RegInfo::registerShift
ULWord registerShift
My register shift value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4050
NTV2DeviceGetNumMixers
UWord NTV2DeviceGetNumMixers(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12755
NTV2DeviceGetSupportedFrameRates
bool NTV2DeviceGetSupportedFrameRates(const NTV2DeviceID inDeviceID, NTV2FrameRateSet &outRates)
Returns a set of distinct NTV2FrameRate values supported on the given device.
Definition: ntv2publicinterface.cpp:1454
NTV2DeviceCanDo3GLevelConversion
bool NTV2DeviceCanDo3GLevelConversion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:793
kDeviceCanDo12GSDI
True if device has 12G SDI connectors.
Definition: ntv2devicefeatures.h:118
NTV2GeometrySet
std::set< NTV2FrameGeometry > NTV2GeometrySet
A set of distinct NTV2FrameGeometry values.
Definition: ntv2publicinterface.h:9156
CNTV2DriverInterface::mInterruptEventHandles
_EventHandles mInterruptEventHandles
For subscribing to each possible event, one for each interrupt type.
Definition: ntv2driverinterface.h:690
NTV2DeviceHasLEDAudioMeters
bool NTV2DeviceHasLEDAudioMeters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7546
kDeviceHasRetailSupport
True if device is supported by AJA "retail" software (AJA ControlPanel & ControlRoom).
Definition: ntv2devicefeatures.h:97
kDeviceGetMaxAudioChannels
The maximum number of audio channels that a single Audio System can support on the device...
Definition: ntv2devicefeatures.h:182
DEVICE_ID_KONA5_OE4
See KONA 5.
Definition: ntv2enums.h:59
NTV2DeviceCanDoThunderbolt
bool NTV2DeviceCanDoThunderbolt(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5983
NTV2DeviceHasBiDirectionalSDI
bool NTV2DeviceHasBiDirectionalSDI(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7145
NTV2DeviceGetHDMIVersion
ULWord NTV2DeviceGetHDMIVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9671
NTV2DeviceCanDoStereoIn
bool NTV2DeviceCanDoStereoIn(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5789
NTV2DeviceCanDoPCMDetection
bool NTV2DeviceCanDoPCMDetection(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4768
AJAAtomic::Increment
static int32_t Increment(int32_t volatile *pTarget)
Definition: atomic.cpp:82
kDeviceCanDoHDMIMultiView
True if device can rasterize 4 HD signals into a single HDMI output.
Definition: ntv2devicefeatures.h:126
NTV2RPCClientAPI::NTV2WaitForInterruptRemote
virtual bool NTV2WaitForInterruptRemote(const INTERRUPT_ENUMS eInterrupt, const ULWord timeOutMs)
Definition: ntv2nubaccess.cpp:2131
NTV2DeviceGetSupportedVideoFormats
bool NTV2DeviceGetSupportedVideoFormats(const NTV2DeviceID inDeviceID, NTV2VideoFormatSet &outFormats)
Returns a set of distinct NTV2VideoFormat values supported on the given device.
Definition: ntv2publicinterface.cpp:1311
NTV2DeviceGetUFCVersion
ULWord NTV2DeviceGetUFCVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13715
NTV2DeviceGetNumAnalogVideoOutputs
UWord NTV2DeviceGetNumAnalogVideoOutputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11015
BITFILE_INFO_STRUCT::checksum
ULWord checksum
Definition: ntv2publicinterface.h:4983
CNTV2DriverInterface::ParseFlashHeader
virtual bool ParseFlashHeader(BITFILE_INFO_STRUCT &outBitfileInfo)
Definition: ntv2driverinterface.cpp:981
NTV2DeviceGetPingLED
ULWord NTV2DeviceGetPingLED(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13523
DEVICE_ID_KONAHDMI
See KONA HDMI.
Definition: ntv2enums.h:68
NTV2DeviceHasPCIeGen2
bool NTV2DeviceHasPCIeGen2(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7934
kDeviceHasPCIeGen2
True if device supports 2nd-generation PCIe.
Definition: ntv2devicefeatures.h:96
kDeviceCanDoAudio6Channels
True if audio system(s) support 6 or more audio channels.
Definition: ntv2devicefeatures.h:50
CNTV2DriverInterface::GetRecordedRegisterWrites
virtual bool GetRecordedRegisterWrites(NTV2RegisterWrites &outRegWrites) const
Answers with the recorded register writes.
Definition: ntv2driverinterface.cpp:1431
NTV2RPCClientAPI::CreateClient
static NTV2RPCClientAPI * CreateClient(NTV2ConnectParams &inParams)
Instantiates a new NTV2RPCClientAPI instance using the given NTV2ConnectParams.
Definition: ntv2nubaccess.cpp:2212
PACKAGE_INFO_STRUCT
Definition: ntv2driverinterface.h:48
CNTV2DriverInterface::GetPackageInformation
virtual bool GetPackageInformation(PACKAGE_INFO_STRUCT &outPkgInfo)
Answers with the IP device&#39;s package information.
Definition: ntv2driverinterface.cpp:742
NTV2DeviceCanReportFrameSize
bool NTV2DeviceCanReportFrameSize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6660
NTV2_WRITEREG_PROFILING
#define NTV2_WRITEREG_PROFILING
Definition: ajatypes.h:74
kDeviceIsLocalPhysical
True if device is local-host-attached, and not remote, software or virtual (new in SDK 17...
Definition: ntv2devicefeatures.h:107
CNTV2DriverInterface::ReleaseStreamForApplicationWithReference
virtual bool ReleaseStreamForApplicationWithReference(const ULWord inAppType, const int32_t inProcessID)
A reference-counted version of CNTV2DriverInterface::ReleaseStreamForApplication useful for process g...
Definition: ntv2driverinterface.cpp:1127
NTV2_CHANNEL2
Specifies channel or FrameStore 2 (or the 2nd item).
Definition: ntv2enums.h:1360
DEVICE_ID_CORVID44_2X4K
See Corvid 44 12G.
Definition: ntv2enums.h:27
CNTV2DriverInterface::GetDeviceID
virtual NTV2DeviceID GetDeviceID(void)
Definition: ntv2driverinterface.cpp:427
NTV2DeviceHasSDIRelays
bool NTV2DeviceHasSDIRelays(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8322
kNTV2EnumsID_FrameGeometry
Identifies the NTV2FrameGeometry enumerated type.
Definition: ntv2devicefeatures.h:246
CNTV2DriverInterface::ReadRegisterMulti
virtual bool ReadRegisterMulti(const ULWord numRegs, ULWord *pOutWhichRegFailed, NTV2RegInfo aRegs[])
Definition: ntv2driverinterface.cpp:479
ULWord64
uint64_t ULWord64
Definition: ajatypes.h:226
NTV2MailBuffer::mBuffer
NTV2Buffer mBuffer
Virtual address of a mail buffer and its length.
Definition: ntv2publicinterface.h:9119
NTV2StreamBuffer::mBuffer
NTV2Buffer mBuffer
Virtual address of a stream buffer and its length.
Definition: ntv2publicinterface.h:9069
NTV2DeviceSpecParser::Results
NTV2ConnectParams Results(void) const
Definition: ntv2nubaccess.h:186
DEVICE_ID_IOEXPRESS
See Io Express.
Definition: ntv2enums.h:39
kDeviceCanDoGPIO
True if device has GPIO interface. (New in SDK 18.0)
Definition: ntv2devicefeatures.h:159
kDeviceCanChangeFrameBufferSize
True if frame buffer sizes are not fixed.
Definition: ntv2devicefeatures.h:38
NTV2DeviceCanDo2KVideo
bool NTV2DeviceCanDo2KVideo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:696
kDeviceGetNum4kQuarterSizeConverters
The number of quarter-size 4K/UHD down-converters on the device.
Definition: ntv2devicefeatures.h:189
NTV2GetRegisters
This is used by the CNTV2Card::ReadRegisters function.
Definition: ntv2publicinterface.h:7692
kNTV2EnumsID_OutputTCIndex
Identifies the NTV2TCIndex enumerated type for output.
Definition: ntv2devicefeatures.h:261
NTV2DeviceGetNumDMAEngines
ULWord NTV2DeviceGetNumDMAEngines(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11399
kDeviceIsDirectAddressable
True if device is direct addressable.
Definition: ntv2devicefeatures.h:105
kDeviceCanDoCapture
True if device has any SDI, HDMI or analog video inputs.
Definition: ntv2devicefeatures.h:55
NTV2DeviceGetNumVideoInputs
UWord NTV2DeviceGetNumVideoInputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13331
kDeviceHasSPIFlashSerial
True if device has serial SPI flash hardware.
Definition: ntv2devicefeatures.h:100
DEVICE_ID_KONALHIDVI
See KONA LHi.
Definition: ntv2enums.h:79
NTV2DeviceGetNumberFrameBuffers
ULWord NTV2DeviceGetNumberFrameBuffers(NTV2DeviceID id, NTV2FrameGeometry fg, NTV2FrameBufferFormat fbf)
Definition: ntv2devicefeatures.cpp:501
CNTV2DriverInterface::WriteRegister
virtual bool WriteRegister(const ULWord inRegNum, const ULWord inValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Updates or replaces all or part of the 32-bit contents of a specific register (real or virtual) on th...
Definition: ntv2driverinterface.cpp:509
NTV2BitFileType
NTV2BitFileType
Definition: ntv2enums.h:3349
kDeviceCanReportFrameSize
True if device can report its frame size.
Definition: ntv2devicefeatures.h:92
NTV2DeviceCanDisableUFC
bool NTV2DeviceCanDisableUFC(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:211
NTV2DeviceCanDo4KVideo
bool NTV2DeviceCanDo4KVideo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:987
ntv2devicescanner.h
Declares the CNTV2DeviceScanner class.
kDeviceCanDoAESAudioOut
True if device has any AES audio output channels (New in SDK 17.1)
Definition: ntv2devicefeatures.h:151
NTV2RPCClientAPI::NTV2ReadRegisterRemote
virtual bool NTV2ReadRegisterRemote(const ULWord regNum, ULWord &outRegValue, const ULWord regMask, const ULWord regShift)
Definition: ntv2nubaccess.cpp:2116
NTV2DeviceCanReportRunningFirmwareDate
bool NTV2DeviceCanReportRunningFirmwareDate(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6757
CNTV2DriverInterface::GetDescription
virtual std::string GetDescription(void) const
Definition: ntv2driverinterface.cpp:1207
CNTV2DriverInterface::NTV2Message
virtual bool NTV2Message(NTV2_HEADER *pInMessage)
Sends a message to the NTV2 driver (the new, improved, preferred way).
Definition: ntv2driverinterface.cpp:626
NTV2DeviceCanDoRateConvert
bool NTV2DeviceCanDoRateConvert(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5194
CNTV2DriverInterface::GetOverlappedMode
static bool GetOverlappedMode(void)
Definition: ntv2driverinterface.cpp:67
BITFILE_INFO_STRUCT::timeStr
char timeStr[(16)]
Definition: ntv2publicinterface.h:4989
NTV2DeviceInfo::deviceIndex
ULWord deviceIndex
Device index number – this will be phased out someday.
Definition: ntv2devicescanner.h:38
kDeviceGetNumHDMIVideoOutputs
The number of HDMI video outputs on the device.
Definition: ntv2devicefeatures.h:207
kDeviceHasSPIv4
Use kDeviceGetSPIVersion instead.
Definition: ntv2devicefeatures.h:103
NTV2DeviceGetSupportedPixelFormats
bool NTV2DeviceGetSupportedPixelFormats(const NTV2DeviceID inDeviceID, NTV2PixelFormats &outFormats)
Returns a set of distinct NTV2FrameBufferFormat values supported on the given device.
Definition: ntv2publicinterface.cpp:1340
BITSTREAM_SWAP
#define BITSTREAM_SWAP
Used in NTV2Bitstream to byte swap bitstream data.
Definition: ntv2publicinterface.h:5738
kDeviceGetNumEmbeddedAudioOutputChannels
The number of SDI-embedded output audio channels supported by the device.
Definition: ntv2devicefeatures.h:201
NTV2DeviceGetNumAudioSystems
UWord NTV2DeviceGetNumAudioSystems(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11111
gCloseCount
static uint32_t gCloseCount(0)
process.h
Declares the AJAProcess class.
NTV2Bitstream
This is used for bitstream maintainance. (New in SDK 16.0)
Definition: ntv2publicinterface.h:8881
DEVICE_ID_KONA5
See KONA 5.
Definition: ntv2enums.h:50
NTV2Buffer
Describes a user-space buffer on the host computer. I have an address and a length, plus some optional attributes (allocated by SDK?, page-aligned? etc.).
Definition: ntv2publicinterface.h:6218
kDeviceGetNumFrameSyncs
The number of frame sync widgets on the device.
Definition: ntv2devicefeatures.h:203
CNTV2DriverInterface::DriverGetBitFileInformation
virtual bool DriverGetBitFileInformation(BITFILE_INFO_STRUCT &outBitFileInfo, const NTV2BitFileType inBitFileType=NTV2_VideoProcBitFile)
defined(NTV2_DEPRECATE_17_2)
Definition: ntv2driverinterface.cpp:639
NTV2DeviceHasAudioMonitorRCAJacks
bool NTV2DeviceHasAudioMonitorRCAJacks(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6951
DEVICE_ID_KONAIP_2110
See KONA IP.
Definition: ntv2enums.h:72
kDeviceHasSPIv5
Use kDeviceGetSPIVersion instead.
Definition: ntv2devicefeatures.h:141
NTV2DeviceGetSupportedOutputDests
bool NTV2DeviceGetSupportedOutputDests(const NTV2DeviceID inDeviceID, NTV2OutputDestinations &outOutputDests, const NTV2IOKinds inKinds=NTV2_IOKINDS_ALL)
Returns a set of distinct NTV2OutputDest values supported on the given device.
Definition: ntv2publicinterface.cpp:1411
kDeviceCanDoSDVideo
True if device can handle SD (Standard Definition) video.
Definition: ntv2devicefeatures.h:84
NTV2DeviceIDToString
std::string NTV2DeviceIDToString(const NTV2DeviceID inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:4608
atomic.h
Declares the AJAAtomic class.
NTV2DeviceCanDoIDSwitch
bool NTV2DeviceCanDoIDSwitch(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3799
CNTV2DriverInterface::~CNTV2DriverInterface
virtual ~CNTV2DriverInterface()
My destructor.
Definition: ntv2driverinterface.cpp:116
NTV2InputSourceSetConstIter
NTV2InputSourceSet::const_iterator NTV2InputSourceSetConstIter
A handy const iterator for iterating over an NTV2InputSourceSet.
Definition: ntv2publicinterface.h:9163
NTV2DeviceCanDoSDIErrorChecks
bool NTV2DeviceCanDoSDIErrorChecks(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5498
kDeviceCanDoDSKOpacity
True if device mixer/keyer supports adjustable opacity.
Definition: ntv2devicefeatures.h:58
BITSTREAM_WRITE
#define BITSTREAM_WRITE
Used in NTV2Bitstream to write a bitstream.
Definition: ntv2publicinterface.h:5736
NTV2MailBuffer::mTimeout
ULWord mTimeout
Timeout (us)
Definition: ntv2publicinterface.h:9123
kDeviceHasXptConnectROM
True if device has a crosspoint connection ROM (New in SDK 17.0)
Definition: ntv2devicefeatures.h:148
kDeviceCanDoDualLink
True if device supports 10-bit RGB input/output over 2-wire SDI.
Definition: ntv2devicefeatures.h:59
NTV2DeviceCanDo12gRouting
bool NTV2DeviceCanDo12gRouting(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:308
RP188_STRUCT::Low
ULWord Low
Definition: ntv2publicinterface.h:4212
NTV2DeviceGetNumEmbeddedAudioInputChannels
UWord NTV2DeviceGetNumEmbeddedAudioInputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11591
NTV2WidgetIDSetConstIter
NTV2WidgetIDSet::const_iterator NTV2WidgetIDSetConstIter
An iterator for iterating over a read-only NTV2WidgetIDSet.
Definition: ntv2signalrouter.h:33
kConnectParamDevIndex
#define kConnectParamDevIndex
Device having this index number.
Definition: ntv2nubaccess.h:27
kDeviceSoftwareCanChangeFrameBufferSize
True if device frame buffer size can be changed.
Definition: ntv2devicefeatures.h:110
NTV2DeviceIsDirectAddressable
bool NTV2DeviceIsDirectAddressable(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8803
NTV2DeviceCanDoStackedAudio
bool NTV2DeviceCanDoStackedAudio(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5692
gOpenCount
static uint32_t gOpenCount(0)
NTV2RPCClientAPI::Description
virtual std::string Description(void) const
Definition: ntv2nubaccess.cpp:2091
kDeviceGetNumAnalogAudioOutputChannels
The number of analog audio output channels on the device.
Definition: ntv2devicefeatures.h:193
DEVICE_ID_KONA5_OE9
See KONA 5.
Definition: ntv2enums.h:64
CNTV2AxiSpiFlash::Read
virtual bool Read(const uint32_t address, std::vector< uint8_t > &data, uint32_t maxBytes=1)
Definition: ntv2spiinterface.cpp:267
kDeviceCanDoAudio192K
True if Audio System(s) support a 192kHz sample rate.
Definition: ntv2devicefeatures.h:121
kDeviceHasSPIv3
Use kDeviceGetSPIVersion instead.
Definition: ntv2devicefeatures.h:102
kDeviceCanDoAnalogVideoOut
True if device has one or more analog video outputs.
Definition: ntv2devicefeatures.h:48
DEC
#define DEC(__x__)
Definition: ntv2publicinterface.h:5769
CNTV2DeviceScanner::GetDeviceInfo
static bool GetDeviceInfo(const ULWord inDeviceIndexNumber, NTV2DeviceInfo &outDeviceInfo, const bool inRescan=(0))
Definition: ntv2devicescanner.cpp:152
CNTV2DriverInterface::StreamBufferOps
virtual bool StreamBufferOps(const NTV2Channel inChannel, NTV2Buffer &inBuffer, ULWord64 bufferCookie, ULWord flags, NTV2StreamBuffer &status)
Definition: ntv2driverinterface.cpp:914
DEVICE_ID_CORVID22
See Corvid 22.
Definition: ntv2enums.h:23
NTV2FrameGeometry
NTV2FrameGeometry
Identifies a particular video frame geometry.
Definition: ntv2enums.h:348
NTV2DeviceGetNumOutputConverters
UWord NTV2DeviceGetNumOutputConverters(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12851
NTV2DeviceSpecParser::PrintErrors
std::ostream & PrintErrors(std::ostream &oss) const
Definition: ntv2nubaccess.cpp:590
kDeviceGetNumLTCInputs
The number of analog LTC inputs on the device.
Definition: ntv2devicefeatures.h:219
NTV2DeviceCanDoWarmBootFPGA
bool NTV2DeviceCanDoWarmBootFPGA(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6370
DEVICE_ID_CORVIDHEVC
See Corvid HEVC.
Definition: ntv2enums.h:35
NTV2DeviceCanDoRGBPlusAlphaOut
bool NTV2DeviceCanDoRGBPlusAlphaOut(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5304
kDeviceGetNumAnalogVideoInputs
The number of analog video inputs on the device.
Definition: ntv2devicefeatures.h:194
kDeviceGetNumBufferedAudioSystems
The total number of audio systems on the device that can read/write audio buffer memory. Includes host audio system, if present. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:224
NTV2DeviceGetNumLUTs
UWord NTV2DeviceGetNumLUTs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12659
kDeviceCanDoHFRRGB
True if device supports 1080p RGB at more than 50Hz frame rates.
Definition: ntv2devicefeatures.h:128
ntv2utils.h
Declares numerous NTV2 utility functions.
kDeviceCanDo12gRouting
True if device supports 12G routing crosspoints.
Definition: ntv2devicefeatures.h:117
CNTV2DriverInterface::SleepMs
virtual Word SleepMs(const LWord msec)
Definition: ntv2driverinterface.cpp:500
NTV2DeviceHasRetailSupport
bool NTV2DeviceHasRetailSupport(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8128
kDeviceGetDACVersion
The version number of the DAC on the device.
Definition: ntv2devicefeatures.h:178
NTV2Buffer::Set
bool Set(const void *pInUserPointer, const size_t inByteCount)
Sets (or resets) me from a client-supplied address and size.
Definition: ntv2publicinterface.cpp:1796
CNTV2DriverInterface::CNTV2DriverInterface
CNTV2DriverInterface()
My default constructor.
Definition: ntv2driverinterface.cpp:72
kDeviceHasMultiRasterWidget
True if device can rasterize 4 HD signals into a single HDMI output.
Definition: ntv2devicefeatures.h:127
NTV2DeviceGetNum2022ChannelsSFP2
UWord NTV2DeviceGetNum2022ChannelsSFP2(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10247
NTV2DeviceGetMaxRegisterNumber
ULWord NTV2DeviceGetMaxRegisterNumber(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9959
NTV2DeviceCanDoHDVideo
bool NTV2DeviceCanDoHDVideo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3605
CNTV2DriverInterface::GetNumSupported
virtual ULWord GetNumSupported(const NTV2NumericParamID inParamID)
Definition: ntv2driverinterface.h:430
CNTV2Bitfile::GetDate
virtual const std::string & GetDate(void) const
Definition: ntv2bitfile.h:129
CNTV2DriverInterface::StreamChannelOps
virtual bool StreamChannelOps(const NTV2Channel inChannel, ULWord flags, NTV2StreamChannel &status)
Definition: ntv2driverinterface.cpp:904
CNTV2SignalRouter::GetWidgetIDs
static bool GetWidgetIDs(const NTV2DeviceID inDeviceID, NTV2WidgetIDSet &outWidgets)
Returns the widget IDs supported by the given device.
Definition: ntv2signalrouter.cpp:375
CNTV2DriverInterface::GetInterruptCount
virtual bool GetInterruptCount(const INTERRUPT_ENUMS eInterrupt, ULWord &outCount)
Answers with the number of interrupts of the given type processed by the driver.
Definition: ntv2driverinterface.cpp:386
kDeviceCanDo2110
True if device supports SMPTE ST2110.
Definition: ntv2devicefeatures.h:119
kDeviceCanDoSDIErrorChecks
True if device can perform SDI error checking.
Definition: ntv2devicefeatures.h:85
CNTV2DriverInterface::OpenRemote
virtual bool OpenRemote(const NTV2DeviceSpecParser &inSpec)
Peforms the housekeeping details of opening the remote/virtual device using the given specParser...
Definition: ntv2driverinterface.cpp:294
kDeviceGetNumOutputConverters
The number of output converter widgets on the device.
Definition: ntv2devicefeatures.h:211
AUTOCIRCULATE_DATA::eCommand
AUTO_CIRC_COMMAND eCommand
Definition: ntv2publicinterface.h:4549
kDeviceCanDoAnalogAudio
True if device has any analog inputs or outputs.
Definition: ntv2devicefeatures.h:46
kDeviceCanDo4KVideo
True if the device can handle 4K/UHD video.
Definition: ntv2devicefeatures.h:44
NTV2DeviceCanDoAudioDelay
bool NTV2DeviceCanDoAudioDelay(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1763
gOverlappedMode
static bool gOverlappedMode((0))
kDeviceGetNumSerialPorts
The number of RS-422 serial ports on the device.
Definition: ntv2devicefeatures.h:213
NTV2_BITFILE_PARTNAME_STRINGLENGTH
#define NTV2_BITFILE_PARTNAME_STRINGLENGTH
Definition: ntv2publicinterface.h:4968
kDeviceCanDoCustomAnc
True if device has SDI ANC inserter/extractor firmware.
Definition: ntv2devicefeatures.h:57
NTV2DeviceGetNumHDMIAudioInputChannels
UWord NTV2DeviceGetNumHDMIAudioInputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11891
ntv2bitfile.h
Declares the CNTV2Bitfile class.
NTV2MailBuffer::mFlags
ULWord mFlags
Action flags.
Definition: ntv2publicinterface.h:9121
DEVICE_ID_IOX3
See Io X3.
Definition: ntv2enums.h:43
NTV2DeviceCanDoVideoProcessing
bool NTV2DeviceCanDoVideoProcessing(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6176
NTV2WidgetID
NTV2WidgetID
Definition: ntv2enums.h:2909
NTV2DeviceCanDo8KVideo
bool NTV2DeviceCanDo8KVideo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1084
NTV2DeviceCanChangeEmbeddedAudioClock
bool NTV2DeviceCanChangeEmbeddedAudioClock(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:17
UWord
uint16_t UWord
Definition: ajatypes.h:221
NTV2DriverVersionDecode_Build
#define NTV2DriverVersionDecode_Build(__vers__)
Definition: ntv2publicinterface.h:5557
kDeviceCanDoHDMIHDROut
True if device supports HDMI HDR output.
Definition: ntv2devicefeatures.h:115
kDeviceCanMeasureTemperature
True if device can measure its FPGA die temperature.
Definition: ntv2devicefeatures.h:91
CNTV2DriverInterface::mEventCounts
_EventCounts mEventCounts
My event tallies, one for each interrupt type. Note that these.
Definition: ntv2driverinterface.h:691
NTV2DeviceCanDoQuarterExpand
bool NTV2DeviceCanDoQuarterExpand(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5097
kDeviceCanDisableUFC
True if there&#39;s at least one UFC, and it can be disabled.
Definition: ntv2devicefeatures.h:39
NTV2DeviceGetNumLTCOutputs
UWord NTV2DeviceGetNumLTCOutputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12467
NTV2_CHANNEL1
Specifies channel or FrameStore 1 (or the first item).
Definition: ntv2enums.h:1359
kDeviceCanReportRunningFirmwareDate
True if device can report its running (and not necessarily installed) firmware date.
Definition: ntv2devicefeatures.h:133
NTV2DeviceHasNWL
bool NTV2DeviceHasNWL(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7837
DEVICE_ID_CORVID44_8KMK
See Corvid 44 12G.
Definition: ntv2enums.h:29
kDeviceCanDoVersalSysMon
True if device supports Versal Adaptive SoC System Monitor.
Definition: ntv2devicefeatures.h:158
kDeviceHasColorSpaceConverterOnChannel2
Calculate based on if NTV2_WgtCSC2 is present.
Definition: ntv2devicefeatures.h:94
DEVICE_ID_IOIP_2022
See Io IP.
Definition: ntv2enums.h:40
kDeviceIsSupported
True if device is supported by this SDK.
Definition: ntv2devicefeatures.h:108
NTV2DeviceHasHEVCM31
bool NTV2DeviceHasHEVCM31(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7449
NTV2DeviceGetSupportedInputSources
bool NTV2DeviceGetSupportedInputSources(const NTV2DeviceID inDeviceID, NTV2InputSourceSet &outInputSources, const NTV2IOKinds inKinds=NTV2_IOKINDS_ALL)
Returns a set of distinct NTV2InputSource values supported on the given device.
Definition: ntv2publicinterface.cpp:1395
NTV2DeviceCanDoRGBLevelAConversion
bool NTV2DeviceCanDoRGBLevelAConversion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5207
xHEX0N
#define xHEX0N(__x__, __n__)
Definition: ntv2publicinterface.h:5768
NTV2DeviceIsExternalToHost
bool NTV2DeviceIsExternalToHost(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8900
NTV2Dictionary
A simple (not thread-safe) set of key/value pairs. (New in SDK 16.3)
Definition: ntv2nubaccess.h:111
kDeviceGetNumMicInputs
The number of microphone inputs on the device.
Definition: ntv2devicefeatures.h:221
kDeviceGetNumHDMIAudioInputChannels
The number of HDMI audio input channels on the device.
Definition: ntv2devicefeatures.h:204
kDeviceCanDoFramePulseSelect
True if device supports frame pulse source independent of reference source.
Definition: ntv2devicefeatures.h:125
NTV2DeviceCanDoSDVideo
bool NTV2DeviceCanDoSDVideo(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5595
CNTV2DriverInterface::WaitForInterrupt
virtual bool WaitForInterrupt(const INTERRUPT_ENUMS eInterrupt, const ULWord timeOutMs=68)
Definition: ntv2driverinterface.cpp:588
DEVICE_ID_IO4KUFC
See Io 4K (UFC Mode).
Definition: ntv2enums.h:38
CNTV2DriverInterface::GetSupportedItems
virtual ULWordSet GetSupportedItems(const NTV2EnumsID inEnumsID)
Definition: ntv2driverinterface.cpp:1488
kDeviceGetNum2022ChannelsSFP2
The number of 2022 channels configured on SFP 2 on the device.
Definition: ntv2devicefeatures.h:218
DEVICE_ID_CORVID1
See Corvid, Corvid 3G.
Definition: ntv2enums.h:22
kDeviceCanDoColorCorrection
True if device has any LUTs.
Definition: ntv2devicefeatures.h:56
NTV2DeviceHasRotaryEncoder
bool NTV2DeviceHasRotaryEncoder(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8225
NTV2RegisterReadsIter
NTV2RegWritesIter NTV2RegisterReadsIter
Definition: ntv2publicinterface.h:4143
kDeviceCanDoHDMIAuxCapture
True if device has HDMI AUX data extractor(s).
Definition: ntv2devicefeatures.h:123
NTV2_IS_VALID_AUDIO_SOURCE
#define NTV2_IS_VALID_AUDIO_SOURCE(_x_)
Definition: ntv2enums.h:2020
NTV2DeviceCanDoAudio192K
bool NTV2DeviceCanDoAudio192K(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1569
kDeviceCanDoLTC
True if device can read LTC (Linear TimeCode) from one of its inputs.
Definition: ntv2devicefeatures.h:68
DEVICE_ID_KONA5_8KMK
See KONA 5.
Definition: ntv2enums.h:51
NTV2DriverVersionDecode_Minor
#define NTV2DriverVersionDecode_Minor(__vers__)
Definition: ntv2publicinterface.h:5555
kDeviceGetSPIFlashVersion
The SPI-flash version on the device. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:226
kDeviceCanDoHDMIOutStereo
True if device supports 3D/stereo HDMI video output.
Definition: ntv2devicefeatures.h:64
DEVICE_ID_CORVID88_GEN3
See Corvid 44.
Definition: ntv2enums.h:33
NTV2AudioSource
NTV2AudioSource
This enum value determines/states where an audio system will obtain its audio samples.
Definition: ntv2enums.h:2005
kDeviceGetDownConverterDelay
The down-converter delay on the device.
Definition: ntv2devicefeatures.h:179
kDeviceHasPWMFanControl
True if device has a PWM-controlled cooling fan. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:156
NTV2DeviceHasHeadphoneJack
bool NTV2DeviceHasHeadphoneJack(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7339
CNTV2Bitfile::GetPartName
virtual const std::string & GetPartName(void) const
Definition: ntv2bitfile.h:144
NTV2DeviceCanDoHDMIHDROut
bool NTV2DeviceCanDoHDMIHDROut(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3217
DIINFO
#define DIINFO(__x__)
Definition: ntv2driverinterface.cpp:38
BITSTREAM_RESET_MODULE
#define BITSTREAM_RESET_MODULE
Used in NTV2Bitstream to reset module.
Definition: ntv2publicinterface.h:5740
NTV2DeviceInfo::vdevUrl
std::string vdevUrl
Definition: ntv2devicescanner.h:100
DEVICE_ID_CORVID44_8K
See Corvid 44 12G.
Definition: ntv2enums.h:28
NTV2_MODE_INPUT
Input (capture) mode, which writes into device SDRAM.
Definition: ntv2enums.h:1244
CNTV2DriverInterface::StopRecordRegisterWrites
virtual bool StopRecordRegisterWrites(void)
Stops recording all WriteRegister calls.
Definition: ntv2driverinterface.cpp:1464
NTV2DeviceGetSupportedGeometries
bool NTV2DeviceGetSupportedGeometries(const NTV2DeviceID inDeviceID, NTV2GeometrySet &outGeometries)
Returns a set of distinct NTV2FrameGeometry values supported on the given device. ...
Definition: ntv2publicinterface.cpp:1380
NTV2DeviceCanDoDVCProHD
bool NTV2DeviceCanDoDVCProHD(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2733
CNTV2DriverInterface::ConfigureSubscription
virtual bool ConfigureSubscription(const bool bSubscribe, const INTERRUPT_ENUMS inInterruptType, PULWord &outSubcriptionHdl)
Definition: ntv2driverinterface.cpp:406
NTV2DeviceCanDoBreakoutBoard
bool NTV2DeviceCanDoBreakoutBoard(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1957
NTV2RPCClientAPI::NTV2WriteRegisterRemote
virtual bool NTV2WriteRegisterRemote(const ULWord regNum, const ULWord regValue, const ULWord regMask, const ULWord regShift)
Definition: ntv2nubaccess.cpp:2121
NTV2DeviceGetNumVideoOutputs
UWord NTV2DeviceGetNumVideoOutputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13427
kDeviceHasNWL
True if device has NorthWest Logic DMA hardware.
Definition: ntv2devicefeatures.h:95
NTV2DeviceGetFrameBufferSize
ULWord NTV2DeviceGetFrameBufferSize(NTV2DeviceID id, NTV2FrameGeometry fg, NTV2FrameBufferFormat fbf)
Definition: ntv2devicefeatures.cpp:325
RP188SourceFilterSelect
RP188SourceFilterSelect
Definition: ntv2publicinterface.h:5226
RP188_STRUCT::DBB
ULWord DBB
Definition: ntv2publicinterface.h:4211
common.h
Private include file for all ajabase sources.
kDeviceGetHDMIVersion
The version number of the HDMI chipset on the device.
Definition: ntv2devicefeatures.h:180
CNTV2DriverInterface::GetInterruptEventCount
virtual bool GetInterruptEventCount(const INTERRUPT_ENUMS inEventCode, ULWord &outCount)
Answers with the number of interrupt events that I successfully waited for.
Definition: ntv2driverinterface.cpp:369
NTV2DeviceCanDoCustomAnc
bool NTV2DeviceCanDoCustomAnc(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2345
kDeviceAudioCanWaitForVBI
True if device audio systems can wait for VBI before starting. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:146
kDeviceGetNumLUTs
The number of LUT widgets on the device.
Definition: ntv2devicefeatures.h:209
CNTV2DriverInterface::IsMBSystemValid
virtual bool IsMBSystemValid(void)
Definition: ntv2driverinterface.cpp:1392
NTV2DeviceCanDoLTCInOnRefPort
bool NTV2DeviceCanDoLTCInOnRefPort(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4283
kDeviceGetNumAnalogAudioInputChannels
The number of analog audio input channels on the device.
Definition: ntv2devicefeatures.h:192
kDeviceCanDoAudio8Channels
True if audio system(s) support 8 or more audio channels.
Definition: ntv2devicefeatures.h:51
kDeviceHasMicrophoneInput
True if device has a microphone input connector.
Definition: ntv2devicefeatures.h:143
CNTV2DriverInterface::BitstreamWrite
virtual bool BitstreamWrite(const NTV2Buffer &inBuffer, const bool inFragment, const bool inSwap)
Definition: ntv2driverinterface.cpp:852
NTV2DeviceCanDoVITC2
bool NTV2DeviceCanDoVITC2(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6273
NTV2DeviceGetNumAESAudioOutputChannels
UWord NTV2DeviceGetNumAESAudioOutputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10631
aja::join
std::string join(const std::vector< std::string > &parts, const std::string &delim)
Definition: common.cpp:468
kDeviceCanDoVITC2
True if device can insert or extract RP-188/VITC2.
Definition: ntv2devicefeatures.h:114
NTV2DeviceGetNumVideoChannels
ULWord NTV2DeviceGetNumVideoChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13235
NTV2DeviceGetSPIFlashVersion
UWord NTV2DeviceGetSPIFlashVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:13619
NTV2ConversionMode
NTV2ConversionMode
Definition: ntv2enums.h:3714
NTV2DeviceIDSet
std::set< NTV2DeviceID > NTV2DeviceIDSet
A set of NTV2DeviceIDs.
Definition: ntv2utils.h:1044
kDeviceHasHEVCM30
True if device has an HEVC M30 encoder/decoder.
Definition: ntv2devicefeatures.h:113
NTV2Buffer::GetHostPointer
void * GetHostPointer(void) const
Definition: ntv2publicinterface.h:6275
DEVICE_ID_KONAX_4CH
See KONA X™.
Definition: ntv2enums.h:82
NTV2DeviceCanDoBreakoutBox
bool NTV2DeviceCanDoBreakoutBox(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2054
kDeviceCanDoAudioMixer
True if device has a firmware audio mixer.
Definition: ntv2devicefeatures.h:122
kNTV2EnumsID_PixelFormat
Identifies the NTV2PixelFormat enumerated type.
Definition: ntv2devicefeatures.h:245
NTV2InputSourceToAudioSource
NTV2AudioSource NTV2InputSourceToAudioSource(const NTV2InputSource inInputSource)
Definition: ntv2utils.cpp:4901
NTV2DeviceCanDoProgrammableRS422
bool NTV2DeviceCanDoProgrammableRS422(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4975
CNTV2DriverInterface::BitstreamStatus
virtual bool BitstreamStatus(NTV2ULWordVector &outRegValues)
Definition: ntv2driverinterface.cpp:879
CNTV2Bitfile
Instances of me can parse a bitfile.
Definition: ntv2bitfile.h:86
kNTV2EnumsID_InputTCIndex
Identifies the NTV2TCIndex enumerated type for input.
Definition: ntv2devicefeatures.h:260
NTV2DeviceHasXilinxDMA
bool NTV2DeviceHasXilinxDMA(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8611
NTV2DeviceCanDoOutputTCIndex
bool NTV2DeviceCanDoOutputTCIndex(const NTV2DeviceID inDeviceID, const NTV2TCIndex inTCIndex)
Definition: ntv2devicefeatures.cpp:1093
DEVICE_ID_CORVID44_GEN3
See Corvid 44.
Definition: ntv2enums.h:30
NTV2DeviceCanDoIP
bool NTV2DeviceCanDoIP(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3896
kNTV2EnumsID_Mode
Identifies the NTV2Mode enumerated type.
Definition: ntv2devicefeatures.h:250
CNTV2DriverInterface::mRegWrites
NTV2RegisterWrites mRegWrites
Stores WriteRegister data.
Definition: ntv2driverinterface.h:693
NTV2DeviceGetNumHDMIAudioOutputChannels
UWord NTV2DeviceGetNumHDMIAudioOutputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:11987
NTV2DeviceCanDoAnalogVideoIn
bool NTV2DeviceCanDoAnalogVideoIn(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1375
kNTV2EnumsID_ConversionMode
Identifies the NTV2ConversionMode enumerated type.
Definition: ntv2devicefeatures.h:258
BITFILE_INFO_STRUCT::structVersion
ULWord structVersion
Definition: ntv2publicinterface.h:4984
CNTV2DriverInterface::IsMBSystemReady
virtual bool IsMBSystemReady(void)
Definition: ntv2driverinterface.cpp:1403
DEVICE_ID_KONA3G
See KONA 3G (UFC Mode).
Definition: ntv2enums.h:46
NTV2DeviceCanDo2110
bool NTV2DeviceCanDo2110(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:502
kDeviceCanDoThunderbolt
True if device connects to the host using a Thunderbolt cable.
Definition: ntv2devicefeatures.h:89
kDeviceHasBiDirectionalAnalogAudio
True if device has a bi-directional analog audio connector.
Definition: ntv2devicefeatures.h:135
NTV2DeviceHasHEVCM30
bool NTV2DeviceHasHEVCM30(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7436
NTV2RegisterWrites
std::vector< NTV2RegInfo > NTV2RegisterWrites
Definition: ntv2publicinterface.h:4138
NTV2DeviceCanDoVersalSysMon
bool NTV2DeviceCanDoVersalSysMon(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6080
AUTOCIRCULATE_P2P_STRUCT
Definition: ntv2publicinterface.h:4836
CNTV2DriverInterface::mSkipRegWrites
bool mSkipRegWrites
True if actual register writes are skipped while recording.
Definition: ntv2driverinterface.h:686
DEVICE_ID_KONAX
See KONA X™.
Definition: ntv2enums.h:80
NTV2RPCClientAPI::ConnectParams
virtual NTV2ConnectParams ConnectParams(void) const
Definition: ntv2nubaccess.cpp:2060
CNTV2DriverInterface::_pRPCAPI
NTV2RPCAPI * _pRPCAPI
Points to remote or software device interface; otherwise NULL for local physical device.
Definition: ntv2driverinterface.h:689
NTV2DeviceCanDoHDMIMultiView
bool NTV2DeviceCanDoHDMIMultiView(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:3314
kDeviceGetNum2022ChannelsSFP1
The number of 2022 channels configured on SFP 1 on the device.
Definition: ntv2devicefeatures.h:217
NTV2RegReads
NTV2RegWrites NTV2RegReads
An ordered sequence of zero or more NTV2RegInfo structs intended for ReadRegister.
Definition: ntv2publicinterface.h:4141
NTV2DeviceSpecParser::InfoString
std::string InfoString(void) const
Definition: ntv2nubaccess.cpp:567
AUTOCIRCULATE_DATA
Definition: ntv2publicinterface.h:4547
NTV2DeviceHasBracketLED
bool NTV2DeviceHasBracketLED(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:7242
CNTV2DriverInterface::ReadRP188Registers
virtual bool ReadRP188Registers(const NTV2Channel inChannel, RP188_STRUCT *pRP188Data)
Definition: ntv2driverinterface.cpp:1243
DEVICE_ID_KONA4UFC
See KONA 4 (UFC Mode).
Definition: ntv2enums.h:49
kDeviceHasRotaryEncoder
True if device has a rotary encoder volume control.
Definition: ntv2devicefeatures.h:140
NTV2DeviceCanChangeFrameBufferSize
bool NTV2DeviceCanChangeFrameBufferSize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:114
NTV2MailBuffer::mChannel
NTV2Channel mChannel
Mail buffer channel.
Definition: ntv2publicinterface.h:9118
NTV2DeviceGetMaxAudioChannels
UWord NTV2DeviceGetMaxAudioChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9863
NTV2RPCClientAPI::NTV2AutoCirculateRemote
virtual bool NTV2AutoCirculateRemote(AUTOCIRCULATE_DATA &autoCircData)
Definition: ntv2nubaccess.cpp:2126
NTV2DeviceGetNumHDMIVideoInputs
UWord NTV2DeviceGetNumHDMIVideoInputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12083
NTV2DeviceCanDoAnalogVideoOut
bool NTV2DeviceCanDoAnalogVideoOut(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:1472
NTV2DeviceCanMeasureTemperature
bool NTV2DeviceCanMeasureTemperature(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:6467
kDeviceGetNumCSCs
The number of colorspace converter widgets on the device.
Definition: ntv2devicefeatures.h:198
kNTV2EnumsID_WidgetID
Identifies the NTV2AudioWidgetID enumerated type.
Definition: ntv2devicefeatures.h:257
NTV2DeviceGetNumReferenceVideoInputs
UWord NTV2DeviceGetNumReferenceVideoInputs(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:12947
NTV2_BITFILE_DESIGNNAME_STRINGLENGTH
#define NTV2_BITFILE_DESIGNNAME_STRINGLENGTH
Definition: ntv2publicinterface.h:4967
kDeviceCanDoCustomHancInsertion
True if device supports custom HANC packet insertion. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:154
NTV2DeviceGetDACVersion
UWord NTV2DeviceGetDACVersion(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:9383
kDeviceCanDoRP188
True if device can insert and/or extract RP-188/VITC.
Definition: ntv2devicefeatures.h:83
kDeviceCanDo8KVideo
True if device supports 8K video formats.
Definition: ntv2devicefeatures.h:120
kNTV2EnumsID_FrameRate
Identifies the NTV2FrameRate enumerated type.
Definition: ntv2devicefeatures.h:247
NTV2DeviceGetNumAnalogAudioInputChannels
UWord NTV2DeviceGetNumAnalogAudioInputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10727
kDeviceHasNTV4FrameStores
True if device has NTV4 FrameStores. (New in SDK 17.0)
Definition: ntv2devicefeatures.h:147
NTV2DeviceCanDoFramePulseSelect
bool NTV2DeviceCanDoFramePulseSelect(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2927
NTV2DeviceCanDoQREZ
bool NTV2DeviceCanDoQREZ(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:5084
CNTV2DriverInterface::AutoCirculate
virtual bool AutoCirculate(AUTOCIRCULATE_DATA &pAutoCircData)
Sends an AutoCirculate command to the NTV2 driver.
Definition: ntv2driverinterface.cpp:601
CNTV2DriverInterface::MailBufferOps
virtual bool MailBufferOps(const NTV2Channel inChannel, NTV2Buffer &inBuffer, ULWord dataSize, ULWord flags, ULWord delay, ULWord timeout, NTV2MailBuffer &status)
Definition: ntv2driverinterface.cpp:928
kDeviceGetNumHDMIAudioOutputChannels
The number of HDMI audio output channels on the device.
Definition: ntv2devicefeatures.h:205
NTV2MailBuffer::mDataSize
ULWord mDataSize
Size of data in the buffer.
Definition: ntv2publicinterface.h:9120
kDeviceGetNumVideoInputs
The number of SDI video inputs on the device.
Definition: ntv2devicefeatures.h:215
nlohmann::json_abi_v3_11_3::detail::void
j template void())
Definition: json.hpp:4893
kDeviceCanThermostat
True if device fan can be thermostatically controlled.
Definition: ntv2devicefeatures.h:111
SAREK_IF_VERSION
#define SAREK_IF_VERSION
Definition: ntv2registersmb.h:14
AJA_NTV2_SDK_VERSION_MINOR
#define AJA_NTV2_SDK_VERSION_MINOR
The SDK minor version number, an unsigned decimal integer.
Definition: ntv2version.h:14
CNTV2DriverInterface::MaxNumDevices
static UWord MaxNumDevices(void)
Definition: ntv2driverinterface.h:65
kDeviceCanDoProRes
True if device can can accommodate Apple ProRes-compressed video in its frame buffers.
Definition: ntv2devicefeatures.h:78
NTV2StreamBuffer::mBufferCookie
ULWord64 mBufferCookie
Buffer User cookie.
Definition: ntv2publicinterface.h:9073
kDeviceCanDoHDVideo
True if device can handle HD (High Definition) video.
Definition: ntv2devicefeatures.h:66
ntv2devicefeatures.h
Declares device capability functions.
kDeviceCanDoHDMIAuxPlayback
True if device has HDMI AUX data inserter(s).
Definition: ntv2devicefeatures.h:124
NTV2DeviceCanDoCustomAux
bool NTV2DeviceCanDoCustomAux(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:2442
kVRegDriverVersion
Packed driver version – use NTV2DriverVersionEncode, NTV2DriverVersionDecode* macros to encode/decod...
Definition: ntv2virtualregisters.h:29
kDeviceGetActiveMemorySize
The size, in bytes, of the device&#39;s active RAM available for video and audio.
Definition: ntv2devicefeatures.h:177
kDeviceGetNumAESAudioInputChannels
The number of AES/EBU audio input channels on the device.
Definition: ntv2devicefeatures.h:190
NTV2DeviceCanDoPIO
bool NTV2DeviceCanDoPIO(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:4865
DEVICE_ID_KONA5_8K
See KONA 5.
Definition: ntv2enums.h:52
DEVICE_ID_TTAP_PRO
See T-TAP Pro.
Definition: ntv2enums.h:94
AJAProcess::IsValid
static bool IsValid(uint64_t pid)
Definition: process.cpp:41
kDeviceHasXilinxDMA
True if device has Xilinx DMA hardware.
Definition: ntv2devicefeatures.h:142
DEVICE_ID_KONAIP_25G
See KONA IP25.
Definition: ntv2enums.h:74
kDeviceGetNumDownConverters
The number of down-converters on the device.
Definition: ntv2devicefeatures.h:199
NTV2InputSourceToReferenceSource
NTV2ReferenceSource NTV2InputSourceToReferenceSource(const NTV2InputSource inInputSource)
Converts a given NTV2InputSource to its equivalent NTV2ReferenceSource value.
Definition: ntv2utils.cpp:5023
kDeviceCanDoAudio96K
True if Audio System(s) support a 96kHz sample rate.
Definition: ntv2devicefeatures.h:52
CNTV2DriverInterface::GetNumRecordedRegisterWrites
virtual ULWord GetNumRecordedRegisterWrites(void) const
Definition: ntv2driverinterface.cpp:1480
kDeviceCanDoAESAudioIn
True if device has any AES audio inputs or outputs.
Definition: ntv2devicefeatures.h:45
DEVICE_ID_KONAXM
See KONA XM™.
Definition: ntv2enums.h:81
kDeviceCanDoAnalogVideoIn
True if device has one or more analog video inputs.
Definition: ntv2devicefeatures.h:47
DEVICE_ID_CORVID3G
See Corvid, Corvid 3G.
Definition: ntv2enums.h:25
kDeviceCanDoRateConvert
True if device can do frame rate conversion.
Definition: ntv2devicefeatures.h:81
kDeviceHasIDSwitch
True if device has a mechanical identification switch. (New in SDK 17.1)
Definition: ntv2devicefeatures.h:152
kDeviceGetNumHDMIVideoInputs
The number of HDMI video inputs on the device.
Definition: ntv2devicefeatures.h:206
NTV2_BITFILE_DATETIME_STRINGLENGTH
#define NTV2_BITFILE_DATETIME_STRINGLENGTH
Definition: ntv2publicinterface.h:4966
PACKAGE_INFO_STRUCT::buildNumber
std::string buildNumber
Definition: ntv2driverinterface.h:50
DEVICE_ID_KONA5_OE5
See KONA 5.
Definition: ntv2enums.h:60
NTV2FrameBufferFormatSetConstIter
NTV2FrameBufferFormatSet::const_iterator NTV2FrameBufferFormatSetConstIter
A handy const iterator for iterating over an NTV2FrameBufferFormatSet.
Definition: ntv2publicinterface.h:9152
CNTV2DriverInterface::GetInterruptEvent
virtual HANDLE GetInterruptEvent(const INTERRUPT_ENUMS eInterruptType)
Definition: ntv2driverinterface.cpp:393
kDeviceCanDoMultiFormat
True if device can simultaneously handle different video formats on more than one SDI input or output...
Definition: ntv2devicefeatures.h:71
NTV2DeviceGetNumAESAudioInputChannels
UWord NTV2DeviceGetNumAESAudioInputChannels(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:10535
gDestructCount
static uint32_t gDestructCount(0)