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