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