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