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