AJA NTV2 SDK  17.5.0.1658
NTV2 SDK 17.5.0.1658
ntv2publicinterface.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: MIT */
7 #include "ntv2publicinterface.h"
8 #include "ntv2devicefeatures.h"
9 #include "ntv2utils.h"
10 #include "ntv2endian.h"
11 #include "ajabase/system/memory.h"
12 #include "ajabase/system/debug.h"
13 #include "ajabase/common/common.h"
14 #include "ntv2registerexpert.h"
15 #include "ntv2nubtypes.h"
16 #include "ntv2version.h"
17 #include "ntv2debug.h"
18 #include <iomanip>
19 #include <locale> // For std::locale, std::numpunct, std::use_facet
20 #include <string.h> // For memset, et al.
21 #include <algorithm> // For set_difference
22 #include <iterator> // For std::inserter
23 #include "ntv2rp188.h"
24 #if !defined(MSWindows)
25  #include <unistd.h>
26 #endif
27 using namespace std;
28 
29 //#define NTV2BUFFER_NO_MEMCMP
30 
31 
33 
34 ostream & operator << (ostream & inOutStr, const NTV2AudioChannelPairs & inSet)
35 {
36  if (inSet.empty())
37  inOutStr << "(none)";
38  else
39  for (NTV2AudioChannelPairsConstIter iter (inSet.begin ()); iter != inSet.end (); ++iter)
40  inOutStr << (iter != inSet.begin() ? ", " : "") << ::NTV2AudioChannelPairToString (*iter, true);
41  return inOutStr;
42 }
43 
44 ostream & operator << (ostream & inOutStr, const NTV2AudioChannelQuads & inSet)
45 {
46  for (NTV2AudioChannelQuadsConstIter iter (inSet.begin ()); iter != inSet.end (); ++iter)
47  inOutStr << (iter != inSet.begin () ? ", " : "") << ::NTV2AudioChannelQuadToString (*iter, true);
48  return inOutStr;
49 }
50 
51 ostream & operator << (ostream & inOutStr, const NTV2AudioChannelOctets & inSet)
52 {
53  for (NTV2AudioChannelOctetsConstIter iter (inSet.begin ()); iter != inSet.end (); ++iter)
54  inOutStr << (iter != inSet.begin () ? ", " : "") << ::NTV2AudioChannelOctetToString (*iter, true);
55  return inOutStr;
56 }
57 
58 ostream & operator << (ostream & inOutStr, const NTV2DoubleArray & inVector)
59 {
60  for (NTV2DoubleArrayConstIter iter (inVector.begin ()); iter != inVector.end (); ++iter)
61  inOutStr << *iter << endl;
62  return inOutStr;
63 }
64 
65 ostream & operator << (ostream & inOutStr, const NTV2DIDSet & inDIDs)
66 {
67  for (NTV2DIDSetConstIter it (inDIDs.begin()); it != inDIDs.end(); )
68  {
69  inOutStr << xHEX0N(uint16_t(*it),2);
70  if (++it != inDIDs.end())
71  inOutStr << ", ";
72  }
73  return inOutStr;
74 }
75 
76 ostream & operator << (ostream & inOutStream, const UWordSequence & inData)
77 {
78  inOutStream << DEC(inData.size()) << " UWords: ";
79  for (UWordSequenceConstIter iter(inData.begin()); iter != inData.end(); )
80  {
81  inOutStream << HEX0N(*iter,4);
82  if (++iter != inData.end())
83  inOutStream << " ";
84  }
85  return inOutStream;
86 }
87 
88 ostream & operator << (ostream & inOutStream, const ULWordSequence & inData)
89 {
90  inOutStream << DEC(inData.size()) << " ULWords: ";
91  for (ULWordSequenceConstIter iter(inData.begin()); iter != inData.end(); )
92  {
93  inOutStream << HEX0N(*iter,8);
94  if (++iter != inData.end())
95  inOutStream << " ";
96  }
97  return inOutStream;
98 }
99 
100 ostream & operator << (ostream & inOutStream, const ULWord64Sequence & inData)
101 {
102  inOutStream << DEC(inData.size()) << " ULWord64s: ";
103  for (ULWord64SequenceConstIter iter(inData.begin()); iter != inData.end(); )
104  {
105  inOutStream << HEX0N(*iter,16);
106  if (++iter != inData.end())
107  inOutStream << " ";
108  }
109  return inOutStream;
110 }
111 
112 
113 NTV2SDIInputStatus::NTV2SDIInputStatus ()
114 {
115  Clear ();
116 }
117 
118 
119 void NTV2SDIInputStatus::Clear (void)
120 {
121  mCRCTallyA = 0;
122  mCRCTallyB = 0;
123  mUnlockTally = 0;
124  mFrameRefClockCount = 0;
125  mGlobalClockCount = 0;
126  mFrameTRSError = false;
127  mLocked = false;
128  mVPIDValidA = false;
129  mVPIDValidB = false;
130 }
131 
132 
133 ostream & NTV2SDIInputStatus::Print (ostream & inOutStream) const
134 {
135  inOutStream << "[CRCA=" << DEC(mCRCTallyA)
136  << " CRCB=" << DEC(mCRCTallyB)
137  << " unlk=" << xHEX0N(mUnlockTally,8)
138  << " frmRefClkCnt=" << xHEX0N(mFrameRefClockCount,16)
139  << " globalClkCnt=" << xHEX0N(mGlobalClockCount,16)
140  << " frmTRS=" << YesNo(mFrameTRSError)
141  << " locked=" << YesNo(mLocked)
142  << " VPIDA=" << YesNo(mVPIDValidA)
143  << " VPIDB=" << YesNo(mVPIDValidB)
144  << "]";
145  return inOutStream;
146 }
147 
148 
149 void NTV2HDMIOutputStatus::Clear (void)
150 {
151  mEnabled = false;
152  mPixel420 = false;
153  mColorSpace = NTV2_INVALID_HDMI_COLORSPACE;
154  mRGBRange = NTV2_INVALID_HDMI_RANGE;
155  mProtocol = NTV2_INVALID_HDMI_PROTOCOL;
156  mVideoStandard = NTV2_STANDARD_INVALID;
157  mVideoRate = NTV2_FRAMERATE_UNKNOWN;
158  mVideoBitDepth = NTV2_INVALID_HDMIBitDepth;
159  mAudioFormat = NTV2_AUDIO_FORMAT_INVALID;
160  mAudioRate = NTV2_AUDIO_RATE_INVALID;
161  mAudioChannels = NTV2_INVALID_HDMI_AUDIO_CHANNELS;
162 }
163 
164 bool NTV2HDMIOutputStatus::SetFromRegValue (const ULWord inData)
165 {
166  Clear();
167  mVideoRate = NTV2FrameRate((inData & kVRegMaskHDMOutVideoFrameRate) >> kVRegShiftHDMOutVideoFrameRate);
168  if (mVideoRate == NTV2_FRAMERATE_UNKNOWN)
169  return true; // Not enabled -- success
170  mEnabled = true;
171  mPixel420 = ((inData & kVRegMaskHDMOutPixel420) >> kVRegShiftHDMOutPixel420) == 1;
172  mColorSpace = NTV2HDMIColorSpace(((inData & kVRegMaskHDMOutColorRGB) >> kVRegShiftHDMOutColorRGB) ? NTV2_HDMIColorSpaceRGB : NTV2_HDMIColorSpaceYCbCr);
173  mRGBRange = NTV2HDMIRange((inData & kVRegMaskHDMOutRangeFull) >> kVRegShiftHDMOutRangeFull);
174  mProtocol = NTV2HDMIProtocol((inData & kVRegMaskHDMOutProtocol) >> kVRegShiftHDMOutProtocol);
175  mVideoStandard = NTV2Standard((inData & kVRegMaskHDMOutVideoStandard) >> kVRegShiftHDMOutVideoStandard);
176  mVideoBitDepth = NTV2HDMIBitDepth((inData & kVRegMaskHDMOutBitDepth) >> kVRegShiftHDMOutBitDepth);
177  mAudioFormat = NTV2AudioFormat((inData & kVRegMaskHDMOutAudioFormat) >> kVRegShiftHDMOutAudioFormat);
178  mAudioRate = NTV2AudioRate((inData & kVRegMaskHDMOutAudioRate) >> kVRegShiftHDMOutAudioRate);
179  mAudioChannels = NTV2HDMIAudioChannels((inData & kVRegMaskHDMOutAudioChannels) >> kVRegShiftHDMOutAudioChannels);
180  return true;
181 }
182 
183 ostream & NTV2HDMIOutputStatus::Print (ostream & inOutStream) const
184 {
185  inOutStream << "Enabled: " << YesNo(mEnabled);
186  if (mEnabled)
187  inOutStream << endl
188  << "Is 4:2:0: " << YesNo(mPixel420) << endl
189  << "Color Space: " << ::NTV2HDMIColorSpaceToString(mColorSpace,true) << endl;
190  if (mColorSpace == NTV2_HDMIColorSpaceRGB)
191  inOutStream << "RGB Range: " << ::NTV2HDMIRangeToString(mRGBRange,true) << endl;
192  inOutStream << "Protocol: " << ::NTV2HDMIProtocolToString(mProtocol,true) << endl
193  << "Video Standard: " << ::NTV2StandardToString(mVideoStandard,true) << endl
194  << "Frame Rate: " << ::NTV2FrameRateToString(mVideoRate,true) << endl
195  << "Bit Depth: " << ::NTV2HDMIBitDepthToString(mVideoBitDepth,true) << endl
196  << "Audio Format: " << ::NTV2AudioFormatToString(mAudioFormat,true) << endl
197  << "Audio Rate: " << ::NTV2AudioRateToString(mAudioRate,true) << endl
198  << "Audio Channels: " << ::NTV2HDMIAudioChannelsToString(mAudioChannels,true);
199  return inOutStream;
200 }
201 
202 
203 AutoCircVidProcInfo::AutoCircVidProcInfo ()
204  : mode (AUTOCIRCVIDPROCMODE_MIX),
205  foregroundVideoCrosspoint (NTV2CROSSPOINT_CHANNEL1),
206  backgroundVideoCrosspoint (NTV2CROSSPOINT_CHANNEL1),
207  foregroundKeyCrosspoint (NTV2CROSSPOINT_CHANNEL1),
208  backgroundKeyCrosspoint (NTV2CROSSPOINT_CHANNEL1),
209  transitionCoefficient (0),
210  transitionSoftness (0)
211 {
212 }
213 
214 
215 AUTOCIRCULATE_DATA::AUTOCIRCULATE_DATA (const AUTO_CIRC_COMMAND inCommand, const NTV2Crosspoint inCrosspoint)
216  : eCommand (inCommand),
217  channelSpec (inCrosspoint),
218  lVal1 (0),
219  lVal2 (0),
220  lVal3 (0),
221  lVal4 (0),
222  lVal5 (0),
223  lVal6 (0),
224  bVal1 (false),
225  bVal2 (false),
226  bVal3 (false),
227  bVal4 (false),
228  bVal5 (false),
229  bVal6 (false),
230  bVal7 (false),
231  bVal8 (false),
232  pvVal1 (AJA_NULL),
233  pvVal2 (AJA_NULL),
234  pvVal3 (AJA_NULL),
235  pvVal4 (AJA_NULL)
236 {
237 }
238 
239 ostream & AUTOCIRCULATE_DATA::Print (ostream & oss) const
240 {
241  static const string sCmds [] = {"ACInit","ACStart","ACStop","ACPause","GetAC","ACFrmStmp",
242  "ACFlush","ACPreRoll","ACXfer","ACAbort","ACStartAt",
243  "ACXfer1","ACXfer2","ACFrmStmp2","ACTask","ACSetActFrm"};
244  if (size_t(eCommand) < sizeof(sCmds))
245  { oss << sCmds[eCommand];
246  switch (eCommand)
247  {
248  case eInitAutoCirc:
249  oss << " " << ::NTV2CrosspointToString(channelSpec);
250  oss << " frms " << DEC(lVal1) << "-" << DEC(lVal2);
251  if (lVal4 > 1) oss << " +" << DEC(lVal4) << " chls";
252  if (lVal6 & AUTOCIRCULATE_WITH_FIELDS) oss << " +FieldMode";
253  if (lVal6 & AUTOCIRCULATE_WITH_HDMIAUX) oss << " +HDMIAux";
254  if (bVal2) oss << " +RP188";
255  if (bVal3) oss << " +FBFChg";
256  if (bVal4) oss << " +FBOChg";
257  if (bVal5) oss << " +ColCorr";
258  if (bVal6) oss << " +VidProc";
259  if (bVal7) oss << " +Anc";
260  if (bVal8) oss << " +LTC";
261  oss << " " << ::NTV2AudioSystemToString(NTV2AudioSystem(lVal3 & 0xF), true);
262  if (!bVal1 && ((lVal3 & 0xF) == NTV2_MAX_NUM_AudioSystemEnums)) oss << " +AudCtrl";
263  if (lVal3 & NTV2_AUDIOSYSTEM_Plus1) oss << " +MLAud1";
264  if (lVal3 & NTV2_AUDIOSYSTEM_Plus2) oss << " +MLAud2";
265  if (lVal3 & NTV2_AUDIOSYSTEM_Plus3) oss << " +MLAud3";
266  break;
267  case eStartAutoCirc:
268  break;
269  case eStartAutoCircAtTime:
270  if (lVal1 || lVal2)
271  oss << " at " << xHEX0N((uint64_t(lVal1) << 32) | uint64_t(lVal2),16);
272  break;
273  case eStopAutoCirc:
274  oss << " " << ::NTV2CrosspointToString(channelSpec);
275  break;
276  case eAbortAutoCirc:
277  oss << " " << ::NTV2CrosspointToString(channelSpec);
278  break;
279  case ePauseAutoCirc:
280  oss << " " << ::NTV2CrosspointToString(channelSpec);
281  if (!bVal1 && lVal6) oss << " at frame " << DEC(lVal6);
282  if (bVal1) oss << " +resume";
283  if (bVal1 && bVal2) oss << " +clearDropCount";
284  break;
285  case eFlushAutoCirculate:
286  oss << " " << ::NTV2CrosspointToString(channelSpec);
287  if (bVal1) oss << " +clearDropCount";
288  break;
289  case ePrerollAutoCirculate:
290  oss << " " << ::NTV2CrosspointToString(channelSpec) << " " << DEC(ULWord(lVal1)) << " frame(s)";
291  break;
292  case eGetAutoCirc:
293  oss << " " << ::NTV2CrosspointToString(channelSpec);
294  break;
295  case eSetActiveFrame:
296  case eGetFrameStamp:
297  oss << " " << ::NTV2CrosspointToString(channelSpec) << " frm " << DEC(ULWord(lVal1));
298  break;
299  default:
300  break;
301  }
302  }
303  return oss;
304 }
305 
306 
307 NTV2_HEADER::NTV2_HEADER (const ULWord inStructureType, const ULWord inStructSizeInBytes)
308  : fHeaderTag (NTV2_HEADER_TAG),
309  fType (inStructureType),
310  fHeaderVersion (NTV2_CURRENT_HEADER_VERSION),
311  fVersion (AUTOCIRCULATE_STRUCT_VERSION),
312  fSizeInBytes (inStructSizeInBytes),
313  fPointerSize (sizeof(int*)),
314  fOperation (0),
315  fResultStatus (0)
316 {
317 }
318 
319 
320 ostream & operator << (ostream & inOutStream, const NTV2_HEADER & inObj)
321 {
322  return inObj.Print (inOutStream);
323 }
324 
325 
326 ostream & NTV2_HEADER::Print (ostream & inOutStream) const
327 {
328  inOutStream << "[";
329  if (NTV2_IS_VALID_HEADER_TAG (fHeaderTag))
330  inOutStream << NTV2_4CC_AS_STRING (fHeaderTag);
331  else
332  inOutStream << "BAD-" << HEX0N(fHeaderTag,8);
333  if (NTV2_IS_VALID_STRUCT_TYPE (fType))
334  inOutStream << NTV2_4CC_AS_STRING (fType);
335  else
336  inOutStream << "|BAD-" << HEX0N(fType,8);
337  inOutStream << " v" << fHeaderVersion << " vers=" << fVersion << " sz=" << fSizeInBytes;
338  return inOutStream << "]";
339 }
340 
341 string NTV2_HEADER::FourCCToString (const ULWord in4CC)
342 {
343  const char * pU32 (reinterpret_cast<const char *>(&in4CC));
344  ostringstream result;
345  size_t badTally(0);
346  result << "'";
347  for (size_t charPos(0); charPos < 4; charPos++)
348  {
349  #if AJATargetBigEndian
350  const char ch(pU32[charPos]);
351  #else // little-endian:
352  const char ch(pU32[3-charPos]);
353  #endif
354  if (ch < ' ' || ch > 126)
355  {result << '.'; badTally++;} // not printable
356  else
357  result << ch;
358  }
359  result << "'";
360  if (badTally)
361  result << " (" << xHEX0N(in4CC,8) << ")";
362  return result.str();
363 }
364 
365 
366 ostream & operator << (ostream & inOutStream, const NTV2_TRAILER & inObj)
367 {
368  inOutStream << "[";
369  if (NTV2_IS_VALID_TRAILER_TAG(inObj.fTrailerTag))
370  inOutStream << NTV2_4CC_AS_STRING(inObj.fTrailerTag);
371  else
372  inOutStream << "BAD-" << HEX0N(inObj.fTrailerTag,8);
373  return inOutStream << " rawVers=" << xHEX0N(inObj.fTrailerVersion,8) << " clientSDK="
374  << DEC(NTV2SDKVersionDecode_Major(inObj.fTrailerVersion))
375  << "." << DEC(NTV2SDKVersionDecode_Minor(inObj.fTrailerVersion))
376  << "." << DEC(NTV2SDKVersionDecode_Point(inObj.fTrailerVersion))
377  << "." << DEC(NTV2SDKVersionDecode_Build(inObj.fTrailerVersion)) << "]";
378 }
379 
380 
381 ostream & operator << (ostream & inOutStream, const NTV2Buffer & inObj)
382 {
383  return inObj.Print (inOutStream);
384 }
385 
386 
387 ostream & NTV2Buffer::Print (ostream & inOutStream) const
388 {
389  inOutStream << (IsAllocatedBySDK() ? "0X" : "0x") << HEX0N(GetRawHostPointer(),16) << "/" << DEC(GetByteCount());
390  return inOutStream;
391 }
392 
393 
394 string NTV2Buffer::AsString (UWord inDumpMaxBytes) const
395 {
396  ostringstream oss;
397  oss << xHEX0N(GetRawHostPointer(),16) << ":" << DEC(GetByteCount()) << " bytes";
398  if (inDumpMaxBytes && GetHostPointer())
399  {
400  oss << ":";
401  if (inDumpMaxBytes > 256)
402  inDumpMaxBytes = 256;
403  if (ULWord(inDumpMaxBytes) > GetByteCount())
404  inDumpMaxBytes = UWord(GetByteCount());
405  const UByte * pBytes (reinterpret_cast<const UByte *>(GetHostPointer()));
406  for (UWord ndx(0); ndx < inDumpMaxBytes; ndx++)
407  oss << HEX0N(uint16_t(pBytes[ndx]),2);
408  }
409  return oss.str();
410 }
411 
412 bool NTV2Buffer::toHexString (std::string & outStr, const size_t inLineBreakInterval) const
413 {
414  outStr.clear();
415  ostringstream oss;
416  if (GetHostPointer() && GetByteCount())
417  for (int ndx(0); ndx < int(GetByteCount()); )
418  {
419  oss << HEX0N(uint16_t(U8(ndx++)),2);
420  if (inLineBreakInterval && ndx < int(GetByteCount()) && ((size_t(ndx) % inLineBreakInterval) == 0))
421  oss << endl;
422  }
423  outStr = oss.str();
424  return !outStr.empty();
425 }
426 
427 static string print_address_offset (const size_t inRadix, const ULWord64 inOffset)
428 {
429  const streamsize maxAddrWidth (sizeof(ULWord64) * 2);
430  ostringstream oss;
431  if (inRadix == 8)
432  oss << OCT0N(inOffset,maxAddrWidth) << ": ";
433  else if (inRadix == 10)
434  oss << DEC0N(inOffset,maxAddrWidth) << ": ";
435  else
436  oss << xHEX0N(inOffset,maxAddrWidth) << ": ";
437  return oss.str();
438 }
439 
440 ostream & NTV2Buffer::Dump (ostream & inOStream,
441  const size_t inStartOffset,
442  const size_t inByteCount,
443  const size_t inRadix,
444  const size_t inBytesPerGroup,
445  const size_t inGroupsPerRow,
446  const size_t inAddressRadix,
447  const bool inShowAscii,
448  const size_t inAddrOffset) const
449 {
450  if (IsNULL())
451  return inOStream;
452  if (inRadix != 8 && inRadix != 10 && inRadix != 16 && inRadix != 2)
453  return inOStream;
454  if (inAddressRadix != 0 && inAddressRadix != 8 && inAddressRadix != 10 && inAddressRadix != 16)
455  return inOStream;
456  if (inBytesPerGroup == 0) // || inGroupsPerRow == 0)
457  return inOStream;
458 
459  {
460  const void * pInStartAddress (GetHostAddress(ULWord(inStartOffset)));
461  size_t bytesRemaining (inByteCount ? inByteCount : GetByteCount());
462  size_t bytesInThisGroup (0);
463  size_t groupsInThisRow (0);
464  const unsigned maxByteWidth (inRadix == 8 ? 4 : (inRadix == 10 ? 3 : (inRadix == 2 ? 8 : 2)));
465  const UByte * pBuffer (reinterpret_cast <const UByte *> (pInStartAddress));
466  const size_t asciiBufferSize (inShowAscii && inGroupsPerRow ? (inBytesPerGroup * inGroupsPerRow + 1) * sizeof (UByte) : 0); // Size in bytes, not chars
467  UByte * pAsciiBuffer (asciiBufferSize ? new UByte[asciiBufferSize / sizeof(UByte)] : AJA_NULL);
468 
469  if (!pInStartAddress)
470  return inOStream;
471 
472  if (pAsciiBuffer)
473  ::memset (pAsciiBuffer, 0, asciiBufferSize);
474 
475  if (inGroupsPerRow && inAddressRadix)
476  inOStream << print_address_offset (inAddressRadix, ULWord64(pBuffer) - ULWord64(pInStartAddress) + ULWord64(inAddrOffset));
477  while (bytesRemaining)
478  {
479  if (inRadix == 2)
480  inOStream << BIN08(*pBuffer);
481  else if (inRadix == 8)
482  inOStream << oOCT(uint16_t(*pBuffer));
483  else if (inRadix == 10)
484  inOStream << DEC0N(uint16_t(*pBuffer),maxByteWidth);
485  else if (inRadix == 16)
486  inOStream << HEX0N(uint16_t(*pBuffer),2);
487 
488  if (pAsciiBuffer)
489  pAsciiBuffer[groupsInThisRow * inBytesPerGroup + bytesInThisGroup] = isprint(*pBuffer) ? *pBuffer : '.';
490  pBuffer++;
491  bytesRemaining--;
492 
493  bytesInThisGroup++;
494  if (bytesInThisGroup >= inBytesPerGroup)
495  {
496  groupsInThisRow++;
497  if (inGroupsPerRow && groupsInThisRow >= inGroupsPerRow)
498  {
499  if (pAsciiBuffer)
500  {
501  inOStream << " " << pAsciiBuffer;
502  ::memset (pAsciiBuffer, 0, asciiBufferSize);
503  }
504  inOStream << endl;
505  if (inAddressRadix && bytesRemaining)
506  inOStream << print_address_offset (inAddressRadix, reinterpret_cast <ULWord64> (pBuffer) - reinterpret_cast <ULWord64> (pInStartAddress) + ULWord64 (inAddrOffset));
507  groupsInThisRow = 0;
508  } // if time for new row
509  else
510  inOStream << " ";
511  bytesInThisGroup = 0;
512  } // if time for new group
513  } // loop til no bytes remaining
514 
515  if (bytesInThisGroup && bytesInThisGroup < inBytesPerGroup && pAsciiBuffer)
516  {
517  groupsInThisRow++;
518  inOStream << string ((inBytesPerGroup - bytesInThisGroup) * maxByteWidth + 1, ' ');
519  }
520 
521  if (groupsInThisRow)
522  {
523  if (groupsInThisRow < inGroupsPerRow && pAsciiBuffer)
524  inOStream << string (((inGroupsPerRow - groupsInThisRow) * inBytesPerGroup * maxByteWidth + (inGroupsPerRow - groupsInThisRow)), ' ');
525  if (pAsciiBuffer)
526  inOStream << pAsciiBuffer;
527  inOStream << endl;
528  }
529  else if (bytesInThisGroup && bytesInThisGroup < inBytesPerGroup)
530  inOStream << endl;
531 
532  if (pAsciiBuffer)
533  delete [] pAsciiBuffer;
534  } // else radix is 16, 10, 8 or 2
535 
536  return inOStream;
537 } // Dump
538 
539 string & NTV2Buffer::Dump ( string & inOutputString,
540  const size_t inStartOffset,
541  const size_t inByteCount,
542  const size_t inRadix,
543  const size_t inBytesPerGroup,
544  const size_t inGroupsPerRow,
545  const size_t inAddressRadix,
546  const bool inShowAscii,
547  const size_t inAddrOffset) const
548 {
549  ostringstream oss;
550  Dump (oss, inStartOffset, inByteCount, inRadix, inBytesPerGroup, inGroupsPerRow, inAddressRadix, inShowAscii, inAddrOffset);
551  inOutputString = oss.str();
552  return inOutputString;
553 }
554 
555 NTV2Buffer & NTV2Buffer::Segment (NTV2Buffer & outPtr, const ULWord inByteOffset, const ULWord inByteCount) const
556 {
557  outPtr.Set(AJA_NULL, 0); // Make invalid
558  if (inByteOffset >= GetByteCount())
559  return outPtr; // Offset past end
560  if (inByteOffset+inByteCount > GetByteCount())
561  return outPtr; // Segment too long
562  outPtr.Set(GetHostAddress(inByteOffset), inByteCount);
563  return outPtr;
564 }
565 
566 
567 bool NTV2Buffer::GetU64s (ULWord64Sequence & outUint64s, const size_t inU64Offset, const size_t inMaxSize, const bool inByteSwap) const
568 {
569  outUint64s.clear();
570  if (IsNULL())
571  return false;
572 
573  size_t maxSize (size_t(GetByteCount()) / sizeof(uint64_t));
574  if (maxSize < inU64Offset)
575  return false; // Past end
576  maxSize -= inU64Offset; // Remove starting offset
577 
578  const uint64_t * pU64 (reinterpret_cast <const uint64_t *> (GetHostAddress(ULWord(inU64Offset * sizeof(uint64_t)))));
579  if (!pU64)
580  return false; // Past end
581 
582  if (inMaxSize && inMaxSize < maxSize)
583  maxSize = inMaxSize;
584 
585  try
586  {
587  outUint64s.reserve(maxSize);
588  for (size_t ndx(0); ndx < maxSize; ndx++)
589  {
590  const uint64_t u64 (*pU64++);
591  outUint64s.push_back(inByteSwap ? NTV2EndianSwap64(u64) : u64);
592  }
593  }
594  catch (...)
595  {
596  outUint64s.clear();
597  outUint64s.reserve(0);
598  return false;
599  }
600  return true;
601 }
602 
603 
604 bool NTV2Buffer::GetU32s (ULWordSequence & outUint32s, const size_t inU32Offset, const size_t inMaxSize, const bool inByteSwap) const
605 {
606  outUint32s.clear();
607  if (IsNULL())
608  return false;
609 
610  size_t maxNumU32s (size_t(GetByteCount()) / sizeof(uint32_t));
611  if (maxNumU32s < inU32Offset)
612  return false; // Past end
613  maxNumU32s -= inU32Offset; // Remove starting offset
614 
615  const uint32_t * pU32 (reinterpret_cast<const uint32_t*>(GetHostAddress(ULWord(inU32Offset * sizeof(uint32_t)))));
616  if (!pU32)
617  return false; // Past end
618 
619  if (inMaxSize && inMaxSize < maxNumU32s)
620  maxNumU32s = inMaxSize;
621 
622  try
623  {
624  outUint32s.reserve(maxNumU32s);
625  for (size_t ndx(0); ndx < maxNumU32s; ndx++)
626  {
627  const uint32_t u32 (*pU32++);
628  outUint32s.push_back(inByteSwap ? NTV2EndianSwap32(u32) : u32);
629  }
630  }
631  catch (...)
632  {
633  outUint32s.clear();
634  outUint32s.reserve(0);
635  return false;
636  }
637  return true;
638 }
639 
640 
641 bool NTV2Buffer::GetU16s (UWordSequence & outUint16s, const size_t inU16Offset, const size_t inMaxSize, const bool inByteSwap) const
642 {
643  outUint16s.clear();
644  if (IsNULL())
645  return false;
646 
647  size_t maxSize (size_t(GetByteCount()) / sizeof(uint16_t));
648  if (maxSize < inU16Offset)
649  return false; // Past end
650  maxSize -= inU16Offset; // Remove starting offset
651 
652  const uint16_t * pU16 (reinterpret_cast <const uint16_t *> (GetHostAddress(ULWord(inU16Offset * sizeof(uint16_t)))));
653  if (!pU16)
654  return false; // Past end
655 
656  if (inMaxSize && inMaxSize < maxSize)
657  maxSize = inMaxSize;
658 
659  try
660  {
661  outUint16s.reserve(maxSize);
662  for (size_t ndx(0); ndx < maxSize; ndx++)
663  {
664  const uint16_t u16 (*pU16++);
665  outUint16s.push_back(inByteSwap ? NTV2EndianSwap16(u16) : u16);
666  }
667  }
668  catch (...)
669  {
670  outUint16s.clear();
671  outUint16s.reserve(0);
672  return false;
673  }
674  return true;
675 }
676 
677 
678 bool NTV2Buffer::GetU8s (UByteSequence & outUint8s, const size_t inU8Offset, const size_t inMaxSize) const
679 {
680  outUint8s.clear();
681  if (IsNULL())
682  return false;
683 
684  size_t maxSize (GetByteCount());
685  if (maxSize < inU8Offset)
686  return false; // Past end
687  maxSize -= inU8Offset; // Remove starting offset
688 
689  const uint8_t * pU8 (reinterpret_cast <const uint8_t *> (GetHostAddress(ULWord(inU8Offset))));
690  if (!pU8)
691  return false; // Past end
692 
693  if (inMaxSize && inMaxSize < maxSize)
694  maxSize = inMaxSize;
695 
696  try
697  {
698  outUint8s.reserve(maxSize);
699  for (size_t ndx(0); ndx < maxSize; ndx++)
700  outUint8s.push_back(*pU8++);
701  }
702  catch (...)
703  {
704  outUint8s.clear();
705  outUint8s.reserve(0);
706  return false;
707  }
708  return true;
709 }
710 
711 bool NTV2Buffer::AppendU8s (UByteSequence & outU8s) const
712 {
713  const uint8_t * pU8 (reinterpret_cast<const uint8_t*> (GetHostPointer()));
714  if (!pU8)
715  return false; // Past end
716  const size_t maxSize (GetByteCount());
717  try
718  {
719  for (size_t ndx(0); ndx < maxSize; ndx++)
720  outU8s.push_back(*pU8++);
721  }
722  catch (...)
723  {
724  return false;
725  }
726  return true;
727 }
728 
729 
730 bool NTV2Buffer::GetString (std::string & outString, const size_t inU8Offset, const size_t inMaxSize) const
731 {
732  outString.clear();
733  if (IsNULL())
734  return false;
735 
736  size_t maxSize(GetByteCount());
737  if (maxSize < inU8Offset)
738  return false; // Past end
739  maxSize -= inU8Offset; // Remove starting offset
740 
741  const uint8_t * pU8 (reinterpret_cast <const uint8_t *> (GetHostAddress(ULWord(inU8Offset))));
742  if (!pU8)
743  return false; // Past end
744 
745  if (inMaxSize && inMaxSize < maxSize)
746  maxSize = inMaxSize;
747 
748  try
749  {
750  outString.reserve(maxSize);
751  for (size_t ndx(0); ndx < maxSize; ndx++)
752  {
753  const char c = *pU8++;
754  if (c)
755  outString += c;
756  else
757  break;
758  }
759  }
760  catch (...)
761  {
762  outString.clear();
763  outString.reserve(0);
764  return false;
765  }
766  return true;
767 }
768 
769 
770 bool NTV2Buffer::PutU64s (const ULWord64Sequence & inU64s, const size_t inU64Offset, const bool inByteSwap)
771 {
772  if (IsNULL())
773  return false; // No buffer or space
774  if (inU64s.empty())
775  return true; // Nothing to copy
776 
777  size_t maxU64s (GetByteCount() / sizeof(uint64_t));
778  uint64_t * pU64 (reinterpret_cast<uint64_t*>(GetHostAddress(ULWord(inU64Offset * sizeof(uint64_t)))));
779  if (!pU64)
780  return false; // Start offset is past end
781  if (maxU64s > inU64Offset)
782  maxU64s -= inU64Offset; // Don't go past end
783  if (maxU64s > inU64s.size())
784  maxU64s = inU64s.size(); // Truncate incoming vector to not go past my end
785  if (inU64s.size() > maxU64s)
786  return false; // Will write past end
787 
788  for (unsigned ndx(0); ndx < maxU64s; ndx++)
789 #if defined(_DEBUG)
790  *pU64++ = inByteSwap ? NTV2EndianSwap64(inU64s.at(ndx)) : inU64s.at(ndx);
791 #else
792  *pU64++ = inByteSwap ? NTV2EndianSwap64(inU64s[ndx]) : inU64s[ndx];
793 #endif
794  return true;
795 }
796 
797 
798 bool NTV2Buffer::PutU32s (const ULWordSequence & inU32s, const size_t inU32Offset, const bool inByteSwap)
799 {
800  if (IsNULL())
801  return false; // No buffer or space
802  if (inU32s.empty())
803  return true; // Nothing to copy
804 
805  size_t maxU32s (GetByteCount() / sizeof(uint32_t));
806  uint32_t * pU32 (reinterpret_cast<uint32_t*>(GetHostAddress(ULWord(inU32Offset * sizeof(uint32_t)))));
807  if (!pU32)
808  return false; // Start offset is past end
809  if (maxU32s > inU32Offset)
810  maxU32s -= inU32Offset; // Don't go past end
811  if (maxU32s > inU32s.size())
812  maxU32s = inU32s.size(); // Truncate incoming vector to not go past my end
813  if (inU32s.size() > maxU32s)
814  return false; // Will write past end
815 
816  for (unsigned ndx(0); ndx < maxU32s; ndx++)
817 #if defined(_DEBUG)
818  *pU32++ = inByteSwap ? NTV2EndianSwap32(inU32s.at(ndx)) : inU32s.at(ndx);
819 #else
820  *pU32++ = inByteSwap ? NTV2EndianSwap32(inU32s[ndx]) : inU32s[ndx];
821 #endif
822  return true;
823 }
824 
825 
826 bool NTV2Buffer::PutU16s (const UWordSequence & inU16s, const size_t inU16Offset, const bool inByteSwap)
827 {
828  if (IsNULL())
829  return false; // No buffer or space
830  if (inU16s.empty())
831  return true; // Nothing to copy
832 
833  size_t maxU16s (GetByteCount() / sizeof(uint16_t));
834  uint16_t * pU16 (reinterpret_cast<uint16_t*>(GetHostAddress(ULWord(inU16Offset * sizeof(uint16_t)))));
835  if (!pU16)
836  return false; // Start offset is past end
837  if (maxU16s > inU16Offset)
838  maxU16s -= inU16Offset; // Don't go past end
839  if (maxU16s > inU16s.size())
840  maxU16s = inU16s.size(); // Truncate incoming vector to not go past my end
841  if (inU16s.size() > maxU16s)
842  return false; // Will write past end
843 
844  for (unsigned ndx(0); ndx < maxU16s; ndx++)
845 #if defined(_DEBUG)
846  *pU16++ = inByteSwap ? NTV2EndianSwap16(inU16s.at(ndx)) : inU16s.at(ndx);
847 #else
848  *pU16++ = inByteSwap ? NTV2EndianSwap16(inU16s[ndx]) : inU16s[ndx];
849 #endif
850  return true;
851 }
852 
853 
854 bool NTV2Buffer::PutU8s (const UByteSequence & inU8s, const size_t inU8Offset)
855 {
856  if (IsNULL())
857  return false; // No buffer or space
858  if (inU8s.empty())
859  return true; // Nothing to copy
860 
861  size_t maxU8s (GetByteCount());
862  uint8_t * pU8 (reinterpret_cast<uint8_t*>(GetHostAddress(ULWord(inU8Offset))));
863  if (!pU8)
864  return false; // Start offset is past end
865  if (maxU8s > inU8Offset)
866  maxU8s -= inU8Offset; // Don't go past end
867  if (maxU8s > inU8s.size())
868  maxU8s = inU8s.size(); // Truncate incoming vector to not go past end
869  if (inU8s.size() > maxU8s)
870  return false; // Will write past end
871 #if 1
872  ::memcpy(pU8, &inU8s[0], maxU8s);
873 #else
874  for (unsigned ndx(0); ndx < maxU8s; ndx++)
875  #if defined(_DEBUG)
876  *pU8++ = inU8s.at(ndx);
877  #else
878  *pU8++ = inU8s[ndx];
879  #endif
880 #endif
881  return true;
882 }
883 
884 
885 ostream & operator << (ostream & inOutStream, const NTV2_RP188 & inObj)
886 {
887  if (inObj.IsValid ())
888  return inOutStream << "{Dx" << HEX0N(inObj.fDBB,8) << "|Lx" << HEX0N(inObj.fLo,8) << "|Hx" << HEX0N(inObj.fHi,8) << "}";
889  else
890  return inOutStream << "{invalid}";
891 }
892 
893 
894 NTV2TimeCodeList & operator << (NTV2TimeCodeList & inOutList, const NTV2_RP188 & inRP188)
895 {
896  inOutList.push_back (inRP188);
897  return inOutList;
898 }
899 
900 
901 ostream & operator << (ostream & inOutStream, const NTV2TimeCodeList & inObj)
902 {
903  inOutStream << inObj.size () << ":[";
904  for (NTV2TimeCodeListConstIter iter (inObj.begin ()); iter != inObj.end (); )
905  {
906  inOutStream << *iter;
907  if (++iter != inObj.end ())
908  inOutStream << ", ";
909  }
910  return inOutStream << "]";
911 }
912 
913 
914 ostream & operator << (std::ostream & inOutStream, const NTV2TimeCodes & inObj)
915 {
916  inOutStream << inObj.size () << ":[";
917  for (NTV2TimeCodesConstIter iter (inObj.begin ()); iter != inObj.end (); )
918  {
919  inOutStream << ::NTV2TCIndexToString (iter->first,true) << "=" << iter->second;
920  if (++iter != inObj.end ())
921  inOutStream << ", ";
922  }
923  return inOutStream << "]";
924 }
925 
926 
927 ostream & operator << (std::ostream & inOutStream, const NTV2TCIndexes & inObj)
928 {
929  for (NTV2TCIndexesConstIter iter (inObj.begin ()); iter != inObj.end (); )
930  {
931  inOutStream << ::NTV2TCIndexToString (*iter);
932  if (++iter != inObj.end ())
933  inOutStream << ", ";
934  }
935  return inOutStream;
936 }
937 
938 
939 NTV2TCIndexes & operator += (NTV2TCIndexes & inOutSet, const NTV2TCIndexes & inSet)
940 {
941  for (NTV2TCIndexesConstIter iter (inSet.begin ()); iter != inSet.end (); ++iter)
942  inOutSet.insert (*iter);
943  return inOutSet;
944 }
945 
946 
947 ostream & operator << (ostream & inOutStream, const FRAME_STAMP & inObj)
948 {
949  return inOutStream << inObj.acHeader
950  << " frmTime=" << inObj.acFrameTime
951  << " reqFrm=" << inObj.acRequestedFrame
952  << " audClkTS=" << inObj.acAudioClockTimeStamp
953  << " audExpAdr=" << hex << inObj.acAudioExpectedAddress << dec
954  << " audInStrtAdr=" << hex << inObj.acAudioInStartAddress << dec
955  << " audInStopAdr=" << hex << inObj.acAudioInStopAddress << dec
956  << " audOutStrtAdr=" << hex << inObj.acAudioOutStartAddress << dec
957  << " audOutStopAdr=" << hex << inObj.acAudioOutStopAddress << dec
958  << " totBytes=" << inObj.acTotalBytesTransferred
959  << " strtSamp=" << inObj.acStartSample
960  << " curTime=" << inObj.acCurrentTime
961  << " curFrm=" << inObj.acCurrentFrame
962  << " curFrmTime=" << inObj.acCurrentFrameTime
963  << " audClkCurTime=" << inObj.acAudioClockCurrentTime
964  << " curAudExpAdr=" << hex << inObj.acCurrentAudioExpectedAddress << dec
965  << " curAudStrtAdr=" << hex << inObj.acCurrentAudioStartAddress << dec
966  << " curFldCnt=" << inObj.acCurrentFieldCount
967  << " curLnCnt=" << inObj.acCurrentLineCount
968  << " curReps=" << inObj.acCurrentReps
969  << " curUsrCookie=" << hex << inObj.acCurrentUserCookie << dec
970  << " acFrame=" << inObj.acFrame
971  << " acRP188=" << inObj.acRP188 // deprecated
972  << " " << inObj.acTrailer;
973 }
974 
975 
976 ostream & operator << (ostream & inOutStream, const NTV2SegmentedDMAInfo & inObj)
977 {
978  if (inObj.acNumSegments > 1)
979  inOutStream << "segs=" << inObj.acNumSegments << " numActBPR=" << inObj.acNumActiveBytesPerRow
980  << " segHostPitc=" << inObj.acSegmentHostPitch << " segDevPitc=" << inObj.acSegmentDevicePitch;
981  else
982  inOutStream << "n/a";
983  return inOutStream;
984 }
985 
986 
987 ostream & operator << (ostream & inOutStream, const AUTOCIRCULATE_TRANSFER & inObj)
988 {
989  #if defined (_DEBUG)
990  NTV2_ASSERT (inObj.NTV2_IS_STRUCT_VALID ());
991  #endif
992  string str (::NTV2FrameBufferFormatToString (inObj.acFrameBufferFormat, true));
993  while (str.find (' ') != string::npos)
994  str.erase (str.find (' '), 1);
995  inOutStream << inObj.acHeader << " vid=" << inObj.acVideoBuffer
996  << " aud=" << inObj.acAudioBuffer
997  << " ancF1=" << inObj.acANCBuffer
998  << " ancF2=" << inObj.acANCField2Buffer
999  << " outTC(" << inObj.acOutputTimeCodes << ")"
1000  << " cookie=" << inObj.acInUserCookie
1001  << " vidDMAoff=" << inObj.acInVideoDMAOffset
1002  << " segDMA=" << inObj.acInSegmentedDMAInfo
1003  << " colcor=" << inObj.acColorCorrection
1004  << " fbf=" << str
1005  << " fbo=" << (inObj.acFrameBufferOrientation == NTV2_FRAMEBUFFER_ORIENTATION_BOTTOMUP ? "flip" : "norm")
1006  << " vidProc=" << inObj.acVidProcInfo
1007  << " quartsz=" << inObj.acVideoQuarterSizeExpand
1008  << " p2p=" << inObj.acPeerToPeerFlags
1009  << " repCnt=" << inObj.acFrameRepeatCount
1010  << " desFrm=" << inObj.acDesiredFrame
1011  << " rp188=" << inObj.acRP188 // deprecated
1012  << " xpt=" << inObj.acCrosspoint
1013  << " status{" << inObj.acTransferStatus << "}"
1014  << " " << inObj.acTrailer;
1015  return inOutStream;
1016 }
1017 
1018 
1019 ostream & operator << (ostream & inOutStream, const AUTOCIRCULATE_TRANSFER_STATUS & inObj)
1020 {
1021  inOutStream << inObj.acHeader << " state=" << ::NTV2AutoCirculateStateToString (inObj.acState)
1022  << " xferFrm=" << inObj.acTransferFrame
1023  << " bufLvl=" << inObj.acBufferLevel
1024  << " frms=" << inObj.acFramesProcessed
1025  << " drops=" << inObj.acFramesDropped
1026  << " " << inObj.acFrameStamp
1027  << " audXfrSz=" << inObj.acAudioTransferSize
1028  << " audStrtSamp=" << inObj.acAudioStartSample
1029  << " ancF1Siz=" << inObj.acAncTransferSize
1030  << " ancF2Siz=" << inObj.acAncField2TransferSize
1031  << " " << inObj.acTrailer;
1032  return inOutStream;
1033 }
1034 
1035 
1036 ostream & operator << (ostream & inOutStream, const NTV2RegisterValueMap & inObj)
1037 {
1038  NTV2RegValueMapConstIter iter (inObj.begin ());
1039  inOutStream << "RegValues:" << inObj.size () << "[";
1040  while (iter != inObj.end ())
1041  {
1042  const NTV2RegisterNumber registerNumber (static_cast <NTV2RegisterNumber> (iter->first));
1043  const ULWord registerValue (iter->second);
1044  inOutStream << ::NTV2RegisterNumberToString (registerNumber) << "=0x" << hex << registerValue << dec;
1045  if (++iter != inObj.end ())
1046  inOutStream << ",";
1047  }
1048  return inOutStream << "]";
1049 }
1050 
1051 
1052 ostream & operator << (ostream & inOutStream, const AutoCircVidProcInfo & inObj)
1053 {
1054  return inOutStream << "{mode=" << ::AutoCircVidProcModeToString (inObj.mode, true)
1055  << ", FGvid=" << ::NTV2CrosspointToString (inObj.foregroundVideoCrosspoint)
1056  << ", BGvid=" << ::NTV2CrosspointToString (inObj.backgroundVideoCrosspoint)
1057  << ", FGkey=" << ::NTV2CrosspointToString (inObj.foregroundKeyCrosspoint)
1058  << ", BGkey=" << ::NTV2CrosspointToString (inObj.backgroundKeyCrosspoint)
1059  << ", transCoeff=" << inObj.transitionCoefficient
1060  << ", transSoftn=" << inObj.transitionSoftness << "}";
1061 }
1062 
1063 
1064 ostream & operator << (ostream & inOutStream, const NTV2ColorCorrectionData & inObj)
1065 {
1066  return inOutStream << "{ccMode=" << ::NTV2ColorCorrectionModeToString (inObj.ccMode)
1067  << ", ccSatVal=" << inObj.ccSaturationValue
1068  << ", ccTables=" << inObj.ccLookupTables << "}";
1069 }
1070 
1071 
1072 NTV2VideoFormatSet & operator += (NTV2VideoFormatSet & inOutSet, const NTV2VideoFormatSet inSet)
1073 {
1074  for (NTV2VideoFormatSetConstIter iter(inSet.begin()); iter != inSet.end(); ++iter)
1075  if (inOutSet.find(*iter) == inOutSet.end())
1076  inOutSet.insert(*iter);
1077  return inOutSet;
1078 }
1079 
1080 
1081 // Implementation of NTV2VideoFormatSet's ostream writer...
1082 ostream & operator << (ostream & inOStream, const NTV2VideoFormatSet & inFormats)
1083 {
1084  NTV2VideoFormatSet::const_iterator iter (inFormats.begin ());
1085 
1086  inOStream << inFormats.size ()
1087  << (inFormats.size () == 1 ? " video format: " : " video format(s): ");
1088 
1089  while (iter != inFormats.end ())
1090  {
1091  inOStream << std::string (::NTV2VideoFormatToString (*iter));
1092  inOStream << (++iter == inFormats.end () ? "" : ", ");
1093  }
1094 
1095  return inOStream;
1096 
1097 } // operator <<
1098 
1099 
1100 // Implementation of NTV2FrameBufferFormatSet's ostream writer...
1101 ostream & operator << (ostream & inOStream, const NTV2PixelFormats & inFormats)
1102 {
1103  NTV2PixelFormatsConstIter iter(inFormats.begin());
1104  inOStream << inFormats.size()
1105  << (inFormats.size() == 1 ? " pixel format: " : " pixel formats: ");
1106 
1107  while (iter != inFormats.end())
1108  {
1109  inOStream << ::NTV2FrameBufferFormatToString(*iter);
1110  inOStream << (++iter == inFormats.end() ? "" : ", ");
1111  }
1112  return inOStream;
1113 
1114 } // operator <<
1115 
1116 
1117 NTV2PixelFormats & operator += (NTV2PixelFormats & inOutSet, const NTV2PixelFormats inFBFs)
1118 {
1119  for (NTV2PixelFormatsConstIter iter(inFBFs.begin()); iter != inFBFs.end(); ++iter)
1120  inOutSet.insert(*iter);
1121  return inOutSet;
1122 }
1123 
1124 
1125 // Implementation of NTV2StandardSet's ostream writer...
1126 ostream & operator << (ostream & inOStream, const NTV2StandardSet & inStandards)
1127 {
1128  NTV2StandardSetConstIter iter (inStandards.begin ());
1129 
1130  inOStream << inStandards.size ()
1131  << (inStandards.size () == 1 ? " standard: " : " standards: ");
1132 
1133  while (iter != inStandards.end ())
1134  {
1135  inOStream << ::NTV2StandardToString(*iter);
1136  inOStream << (++iter == inStandards.end () ? "" : ", ");
1137  }
1138 
1139  return inOStream;
1140 }
1141 
1142 
1143 NTV2StandardSet & operator += (NTV2StandardSet & inOutSet, const NTV2StandardSet inSet)
1144 {
1145  for (NTV2StandardSetConstIter iter(inSet.begin ()); iter != inSet.end(); ++iter)
1146  inOutSet.insert(*iter);
1147  return inOutSet;
1148 }
1149 
1150 
1151 // Implementation of NTV2GeometrySet's ostream writer...
1152 ostream & operator << (ostream & inOStream, const NTV2GeometrySet & inGeometries)
1153 {
1154  NTV2GeometrySetConstIter iter (inGeometries.begin ());
1155  inOStream << inGeometries.size ()
1156  << (inGeometries.size () == 1 ? " geometry: " : " geometries: ");
1157  while (iter != inGeometries.end ())
1158  {
1159  inOStream << ::NTV2FrameGeometryToString(*iter);
1160  inOStream << (++iter == inGeometries.end () ? "" : ", ");
1161  }
1162  return inOStream;
1163 }
1164 
1165 
1166 NTV2GeometrySet & operator += (NTV2GeometrySet & inOutSet, const NTV2GeometrySet inSet)
1167 {
1168  for (NTV2GeometrySetConstIter iter(inSet.begin ()); iter != inSet.end(); ++iter)
1169  inOutSet.insert(*iter);
1170  return inOutSet;
1171 }
1172 
1173 
1174 // Implementation of NTV2FrameBufferFormatSet's ostream writer...
1175 ostream & operator << (ostream & inOStream, const NTV2InputSourceSet & inSet)
1176 {
1177  NTV2InputSourceSetConstIter iter(inSet.begin());
1178  inOStream << inSet.size()
1179  << (inSet.size() == 1 ? " input: " : " inputs: ");
1180  while (iter != inSet.end())
1181  {
1182  inOStream << ::NTV2InputSourceToString (*iter);
1183  inOStream << (++iter == inSet.end() ? "" : ", ");
1184  }
1185  return inOStream;
1186 } // operator <<
1187 
1188 
1189 NTV2InputSourceSet & operator += (NTV2InputSourceSet & inOutSet, const NTV2InputSourceSet & inSet)
1190 {
1191  for (NTV2InputSourceSetConstIter iter (inSet.begin ()); iter != inSet.end (); ++iter)
1192  inOutSet.insert (*iter);
1193  return inOutSet;
1194 }
1195 
1196 
1197 ostream & operator << (ostream & inOStream, const NTV2OutputDestinations & inSet)
1198 {
1199  NTV2OutputDestinationsConstIter iter(inSet.begin());
1200  inOStream << inSet.size()
1201  << (inSet.size() == 1 ? " output: " : " outputs: ");
1202  while (iter != inSet.end())
1203  {
1204  inOStream << ::NTV2OutputDestinationToString(*iter);
1205  inOStream << (++iter == inSet.end() ? "" : ", ");
1206  }
1207  return inOStream;
1208 }
1209 
1210 
1211 NTV2OutputDestinations & operator += (NTV2OutputDestinations & inOutSet, const NTV2OutputDestinations & inSet)
1212 {
1213  for (NTV2OutputDestinationsConstIter iter(inSet.begin()); iter != inSet.end(); ++iter)
1214  inOutSet.insert(*iter);
1215  return inOutSet;
1216 }
1217 
1218 bool NTV2GetSupportedPixelFormats (NTV2PixelFormats & outFormats)
1219 {
1220  outFormats.clear();
1221  const NTV2DeviceIDSet devIDs (::NTV2GetSupportedDevices());
1222  for (NTV2DeviceIDSetConstIter it(devIDs.begin()); it != devIDs.end(); ++it)
1223  {
1224  NTV2PixelFormats fmts;
1225  ::NTV2DeviceGetSupportedPixelFormats(*it, fmts);
1226  for (NTV2PixelFormatsConstIter fit(fmts.begin()); fit != fmts.end(); ++fit)
1227  if (outFormats.find(*fit) == outFormats.end())
1228  outFormats.insert(*fit);
1229  }
1230  return true;
1231 }
1232 
1233 bool NTV2GetUnsupportedPixelFormats (NTV2PixelFormats & outFormats)
1234 {
1235  NTV2PixelFormats usedFormats;
1236  ::NTV2GetSupportedPixelFormats(usedFormats);
1237  for (NTV2PixelFormat pf(NTV2_FBF_FIRST); pf < NTV2_FBF_LAST; pf = NTV2PixelFormat(pf+1))
1238  if (usedFormats.find(pf) == usedFormats.end()) // if unused
1239  outFormats.insert(pf);
1240  return true;
1241 }
1242 
1243 bool NTV2GetSupportedStandards (NTV2StandardSet & outStandards)
1244 {
1245  outStandards.clear();
1246  const NTV2DeviceIDSet devIDs (::NTV2GetSupportedDevices());
1247  for (NTV2DeviceIDSetConstIter it(devIDs.begin()); it != devIDs.end(); ++it)
1248  {
1249  NTV2StandardSet stds;
1250  ::NTV2DeviceGetSupportedStandards(*it, stds);
1251  for (NTV2StandardSetConstIter sit(stds.begin()); sit != stds.end(); ++sit)
1252  if (outStandards.find(*sit) == outStandards.end())
1253  outStandards.insert(*sit);
1254  }
1255  return true;
1256 }
1257 
1258 bool NTV2GetUnsupportedStandards (NTV2StandardSet & outStandards)
1259 {
1260  NTV2StandardSet usedStandards;
1261  ::NTV2GetSupportedStandards(usedStandards);
1262  for (NTV2Standard st(NTV2_STANDARD_1080); st < NTV2_NUM_STANDARDS; st = NTV2Standard(st+1))
1263  if (usedStandards.find(st) == usedStandards.end()) // if unused
1264  outStandards.insert(st);
1265  return true;
1266 }
1267 
1268 
1269 // This needs to be moved into a C++ compatible "device features" module:
1270 bool NTV2DeviceGetSupportedVideoFormats (const NTV2DeviceID inDeviceID, NTV2VideoFormatSet & outFormats)
1271 {
1272  bool isOkay(true);
1273  outFormats.clear();
1274 
1275  for (NTV2VideoFormat vf(NTV2_FORMAT_UNKNOWN); vf < NTV2_MAX_NUM_VIDEO_FORMATS; vf = NTV2VideoFormat(vf+1))
1276  {
1277  if (inDeviceID != DEVICE_ID_INVALID && !::NTV2DeviceCanDoVideoFormat(inDeviceID, vf))
1278  continue; // Valid devID specified and VF not supported on that device
1279  if (inDeviceID == DEVICE_ID_INVALID && !NTV2_IS_VALID_VIDEO_FORMAT(vf))
1280  continue; // Invalid devID specified and invalid VF
1281  try
1282  {
1283  outFormats.insert(vf);
1284  }
1285  catch (const std::bad_alloc &)
1286  {
1287  isOkay = false;
1288  outFormats.clear();
1289  break;
1290  }
1291  } // for each video format
1292 
1293  NTV2_ASSERT ((isOkay && !outFormats.empty()) || (!isOkay && outFormats.empty()));
1294  return isOkay;
1295 
1296 } // NTV2DeviceGetSupportedVideoFormats
1297 
1298 // This needs to be moved into a C++ compatible "device features" module:
1299 bool NTV2DeviceGetSupportedPixelFormats (const NTV2DeviceID inDeviceID, NTV2PixelFormats & outFormats)
1300 {
1301  bool isOkay(true);
1302  outFormats.clear();
1303 
1304  for (NTV2PixelFormat pixelFormat(NTV2_FBF_FIRST); pixelFormat < NTV2_FBF_LAST; pixelFormat = NTV2PixelFormat(pixelFormat+1))
1305  if (::NTV2DeviceCanDoFrameBufferFormat (inDeviceID, pixelFormat))
1306  try
1307  {
1308  outFormats.insert(pixelFormat);
1309  }
1310  catch (const std::bad_alloc &)
1311  {
1312  isOkay = false;
1313  outFormats.clear();
1314  break;
1315  }
1316 
1317  NTV2_ASSERT ((isOkay && !outFormats.empty() ) || (!isOkay && outFormats.empty() ));
1318  return isOkay;
1319 
1320 } // NTV2DeviceGetSupportedPixelFormats
1321 
1322 // This needs to be moved into a C++ compatible "device features" module:
1323 bool NTV2DeviceGetSupportedStandards (const NTV2DeviceID inDeviceID, NTV2StandardSet & outStandards)
1324 {
1325  NTV2VideoFormatSet videoFormats;
1326  outStandards.clear();
1327  if (!::NTV2DeviceGetSupportedVideoFormats(inDeviceID, videoFormats))
1328  return false;
1329  for (NTV2VideoFormatSetConstIter it(videoFormats.begin()); it != videoFormats.end(); ++it)
1330  {
1331  const NTV2Standard std (::GetNTV2StandardFromVideoFormat(*it));
1332  if (NTV2_IS_VALID_STANDARD(std) && outStandards.find(std) == outStandards.end())
1333  outStandards.insert(std);
1334  }
1335  return true;
1336 }
1337 
1338 // This needs to be moved into a C++ compatible "device features" module:
1339 bool NTV2DeviceGetSupportedGeometries (const NTV2DeviceID inDeviceID, NTV2GeometrySet & outGeometries)
1340 {
1341  NTV2VideoFormatSet videoFormats;
1342  outGeometries.clear();
1343  if (!::NTV2DeviceGetSupportedVideoFormats(inDeviceID, videoFormats))
1344  return false;
1345  for (NTV2VideoFormatSetConstIter it(videoFormats.begin()); it != videoFormats.end(); ++it)
1346  {
1347  const NTV2FrameGeometry fg (::GetNTV2FrameGeometryFromVideoFormat(*it));
1348  if (NTV2_IS_VALID_NTV2FrameGeometry(fg))
1349  outGeometries += ::GetRelatedGeometries(fg);
1350  }
1351  return true;
1352 }
1353 
1354 bool NTV2DeviceGetSupportedInputSources (const NTV2DeviceID inDeviceID, NTV2InputSourceSet & outInputSources, const NTV2IOKinds inKinds)
1355 {
1356  outInputSources.clear();
1357  if (!NTV2_IS_VALID_IOKINDS(inKinds))
1358  return false;
1359  for (NTV2InputSource src(NTV2_INPUTSOURCE_ANALOG1); src < NTV2_NUM_INPUTSOURCES; src = NTV2InputSource(src+1))
1360  { const bool ok (inDeviceID == DEVICE_ID_INVALID ? true : ::NTV2DeviceCanDoInputSource(inDeviceID, src));
1361  if (ok)
1362  if ( (NTV2_INPUT_SOURCE_IS_SDI(src) && (inKinds & NTV2_IOKINDS_SDI))
1363  || (NTV2_INPUT_SOURCE_IS_HDMI(src) && (inKinds & NTV2_IOKINDS_HDMI))
1364  || (NTV2_INPUT_SOURCE_IS_ANALOG(src) && (inKinds & NTV2_IOKINDS_ANALOG)) )
1365  outInputSources.insert(src);
1366  }
1367  return true;
1368 }
1369 
1370 bool NTV2DeviceGetSupportedOutputDests (const NTV2DeviceID inDeviceID, NTV2OutputDestinations & outOutputDests, const NTV2IOKinds inKinds)
1371 {
1372  static const NTV2OutputDest sDsts[] = { NTV2_OUTPUTDESTINATION_ANALOG1, NTV2_OUTPUTDESTINATION_HDMI1,
1373  NTV2_OUTPUTDESTINATION_SDI1, NTV2_OUTPUTDESTINATION_SDI2, NTV2_OUTPUTDESTINATION_SDI3, NTV2_OUTPUTDESTINATION_SDI4,
1374  NTV2_OUTPUTDESTINATION_SDI5, NTV2_OUTPUTDESTINATION_SDI6, NTV2_OUTPUTDESTINATION_SDI7, NTV2_OUTPUTDESTINATION_SDI8};
1375  outOutputDests.clear();
1376  if (!NTV2_IS_VALID_IOKINDS(inKinds))
1377  return false;
1378  for (size_t ndx(0); ndx < 10; ndx++)
1379  { const NTV2OutputDest dst(sDsts[ndx]);
1380  const bool ok (inDeviceID == DEVICE_ID_INVALID ? true : ::NTV2DeviceCanDoOutputDestination(inDeviceID, dst));
1381  if (ok)
1382  if ( (NTV2_OUTPUT_DEST_IS_SDI(dst) && (inKinds & NTV2_IOKINDS_SDI))
1383  || (NTV2_OUTPUT_DEST_IS_HDMI(dst) && (inKinds & NTV2_IOKINDS_HDMI))
1384  || (NTV2_OUTPUT_DEST_IS_ANALOG(dst) && (inKinds & NTV2_IOKINDS_ANALOG)) )
1385  outOutputDests.insert(dst);
1386  }
1387  return true;
1388 }
1389 
1390 ostream & operator << (ostream & oss, const NTV2FrameRateSet & inSet)
1391 {
1392  NTV2FrameRateSetConstIter it(inSet.begin());
1393  oss << inSet.size()
1394  << (inSet.size() == 1 ? " rate: " : " rates: ");
1395  while (it != inSet.end())
1396  {
1397  oss << ::NTV2FrameRateToString(*it);
1398  oss << (++it == inSet.end() ? "" : ", ");
1399  }
1400  return oss;
1401 }
1402 
1403 NTV2FrameRateSet & operator += (NTV2FrameRateSet & inOutSet, const NTV2FrameRateSet & inSet)
1404 {
1405  for (NTV2FrameRateSetConstIter it(inSet.begin()); it != inSet.end(); ++it)
1406  if (inOutSet.find(*it) == inOutSet.end())
1407  inOutSet.insert(*it);
1408  return inOutSet;
1409 }
1410 
1411 bool NTV2DeviceGetSupportedFrameRates (const NTV2DeviceID inDeviceID, NTV2FrameRateSet & outRates)
1412 {
1413  outRates.clear();
1414  NTV2VideoFormatSet vfs;
1415  if (!::NTV2DeviceGetSupportedVideoFormats (inDeviceID, vfs))
1416  return false;
1417  for (NTV2VideoFormatSetConstIter it(vfs.begin()); it != vfs.end(); ++it)
1418  { const NTV2FrameRate fr (::GetNTV2FrameRateFromVideoFormat(*it));
1419  if (NTV2_IS_VALID_NTV2FrameRate(fr))
1420  outRates.insert(fr);
1421  }
1422  return true;
1423 }
1424 
1425 
1426 ostream & operator << (ostream & inOutStrm, const NTV2SegmentedXferInfo & inRun)
1427 {
1428  return inRun.Print(inOutStrm);
1429 }
1430 
1431 
1432 // Implementation of NTV2AutoCirculateStateToString...
1433 string NTV2AutoCirculateStateToString (const NTV2AutoCirculateState inState)
1434 {
1435  static const char * sStateStrings [] = { "Disabled", "Initializing", "Starting", "Paused", "Stopping", "Running", "StartingAtTime", AJA_NULL};
1436  if (inState >= NTV2_AUTOCIRCULATE_DISABLED && inState <= NTV2_AUTOCIRCULATE_STARTING_AT_TIME)
1437  return string (sStateStrings [inState]);
1438  else
1439  return "<invalid>";
1440 }
1441 
1442 
1443 
1444 NTV2_TRAILER::NTV2_TRAILER ()
1445  : fTrailerVersion (NTV2SDKVersionEncode(AJA_NTV2_SDK_VERSION_MAJOR, AJA_NTV2_SDK_VERSION_MINOR, AJA_NTV2_SDK_VERSION_POINT, AJA_NTV2_SDK_BUILD_NUMBER)),
1446  fTrailerTag (NTV2_TRAILER_TAG)
1447 {
1448 }
1449 
1450 
1451 NTV2FrameSize::operator NTV2FrameGeometry() const // Cast to NTV2FrameGeometry
1452 {
1453  return isValid() ? ::GetGeometryFromFrameDimensions(*this) : NTV2_FG_INVALID;
1454 }
1455 
1456 ULWord NTV2FrameSize::FGWidth (const NTV2FrameGeometry fg)
1457 { // Requires C++11:
1458  static const FGSizesMap sFGWdths = { {NTV2_FG_720x486, 720},
1459  {NTV2_FG_720x508, 720},
1460  {NTV2_FG_720x514, 720},
1461  {NTV2_FG_720x576, 720},
1462  {NTV2_FG_720x598, 720},
1463  {NTV2_FG_720x612, 720},
1464  {NTV2_FG_1280x720, 1280},
1465  {NTV2_FG_1280x740, 1280},
1466  {NTV2_FG_1920x1080, 1920},
1467  {NTV2_FG_1920x1114, 1920},
1468  {NTV2_FG_1920x1112, 1920},
1469  {NTV2_FG_2048x1080, 2048},
1470  {NTV2_FG_2048x1112, 2048},
1471  {NTV2_FG_2048x1114, 2048},
1472  {NTV2_FG_2048x1556, 2048},
1473  {NTV2_FG_2048x1588, 2048},
1474  {NTV2_FG_3840x2160, 3840},
1475  {NTV2_FG_4096x2160, 4096},
1476  {NTV2_FG_7680x4320, 7680},
1477  {NTV2_FG_8192x4320, 8192} };
1478  FGSizesMapCI it (sFGWdths.find(fg));
1479  return it != sFGWdths.end() ? it->second : 0;
1480 }
1481 
1482 ULWord NTV2FrameSize::FGHeight (const NTV2FrameGeometry fg)
1483 { // Requires C++11:
1484  static const FGSizesMap sFGHghts = { {NTV2_FG_720x486, 486},
1485  {NTV2_FG_720x508, 508},
1486  {NTV2_FG_720x514, 514},
1487  {NTV2_FG_720x576, 576},
1488  {NTV2_FG_720x598, 598},
1489  {NTV2_FG_720x612, 612},
1490  {NTV2_FG_1280x720, 720},
1491  {NTV2_FG_1280x740, 740},
1492  {NTV2_FG_2048x1556, 1556},
1493  {NTV2_FG_2048x1588, 1588},
1494  {NTV2_FG_1920x1080, 1080},
1495  {NTV2_FG_2048x1080, 1080},
1496  {NTV2_FG_1920x1114, 1114},
1497  {NTV2_FG_2048x1114, 1114},
1498  {NTV2_FG_1920x1112, 1112},
1499  {NTV2_FG_2048x1112, 1112},
1500  {NTV2_FG_3840x2160, 2160},
1501  {NTV2_FG_4096x2160, 2160},
1502  {NTV2_FG_7680x4320, 4320},
1503  {NTV2_FG_8192x4320, 4320} };
1504  FGSizesMapCI it (sFGHghts.find(fg));
1505  return it != sFGHghts.end() ? it->second : 0;
1506 }
1507 
1508 
1509 static const string sSegXferUnits[] = {"", " U8", " U16", "", " U32", "", "", "", " U64", ""};
1510 
1511 ostream & NTV2SegmentedXferInfo::Print (ostream & inStrm, const bool inDumpSegments) const
1512 {
1513  if (!isValid())
1514  return inStrm << "(invalid)";
1515  if (inDumpSegments)
1516  {
1517  // TBD
1518  }
1519  else
1520  {
1521  inStrm << DEC(getSegmentCount()) << " x " << DEC(getSegmentLength())
1522  << sSegXferUnits[getElementLength()] << " segs";
1523  if (getSourceOffset())
1524  inStrm << " srcOff=" << xHEX0N(getSourceOffset(),8);
1525  if (getSegmentCount() > 1)
1526  inStrm << " srcSpan=" << xHEX0N(getSourcePitch(),8) << (isSourceBottomUp()?" VF":"");
1527  if (getDestOffset())
1528  inStrm << " dstOff=" << xHEX0N(getDestOffset(),8);
1529  if (getSegmentCount() > 1)
1530  inStrm << " dstSpan=" << xHEX0N(getDestPitch(),8) << (isDestBottomUp()?" VF":"");
1531  inStrm << " totElm=" << DEC(getTotalElements()) << " totByt=" << xHEX0N(getTotalBytes(),8);
1532  }
1533  return inStrm;
1534 }
1535 
1536 string NTV2SegmentedXferInfo::getSourceCode (const bool inInclDecl) const
1537 {
1538  static string var("segInfo");
1539  ostringstream oss;
1540  string units("\t// bytes");
1541  if (!isValid())
1542  return "";
1543  if (inInclDecl)
1544  oss << "NTV2SegmentedXferInfo " << var << ";" << endl;
1545  if (getElementLength() > 1)
1546  {
1547  units = "\t// " + sSegXferUnits[getElementLength()] + "s";
1548  oss << var << ".setElementLength(" << getElementLength() << ");" << endl;
1549  }
1550  oss << var << ".setSegmentCount(" << DEC(getSegmentCount()) << ");" << endl;
1551  oss << var << ".setSegmentLength(" << DEC(getSegmentLength()) << ");" << units << endl;
1552  if (getSourceOffset())
1553  oss << var << ".setSourceOffset(" << DEC(getSourceOffset()) << ");" << units << endl;
1554  oss << var << ".setSourcePitch(" << DEC(getSourcePitch()) << ");" << units << endl;
1555  if (isSourceBottomUp())
1556  oss << var << ".setSourceDirection(false);" << endl;
1557  if (getDestOffset())
1558  oss << var << ".setDestOffset(" << DEC(getDestOffset()) << ");" << units << endl;
1559  if (getDestPitch())
1560  oss << var << ".setDestPitch(" << DEC(getDestPitch()) << ");" << units << endl;
1561  if (isDestBottomUp())
1562  oss << var << ".setDestDirection(false);" << endl;
1563  return oss.str();
1564 }
1565 
1566 bool NTV2SegmentedXferInfo::containsElementAtOffset (const ULWord inElementOffset) const
1567 {
1568  if (!isValid())
1569  return false;
1570  if (getSegmentCount() == 1)
1571  {
1572  if (inElementOffset >= getSourceOffset())
1573  if (inElementOffset < getSourceOffset()+getSegmentLength())
1574  return true;
1575  return false;
1576  }
1577  ULWord offset(getSourceOffset());
1578  for (ULWord seg(0); seg < getSegmentCount(); seg++)
1579  {
1580  if (inElementOffset < offset)
1581  return false; // past element of interest already
1582  if (inElementOffset < offset+getSegmentLength())
1583  return true; // must be within this segment
1584  offset += getSourcePitch(); // skip to next segment
1585  }
1586  return false;
1587 }
1588 
1589 bool NTV2SegmentedXferInfo::operator != (const NTV2SegmentedXferInfo & inRHS) const
1590 {
1591  if (getElementLength() != inRHS.getElementLength())
1592  // FUTURE TBD: Need to transform RHS to match ElementLength so as to make apples-to-apples comparison
1593  return true; // For now, fail
1594  if (getSegmentCount() != inRHS.getSegmentCount())
1595  return true;
1596  if (getSegmentLength() != inRHS.getSegmentLength())
1597  return true;
1598  if (getSourceOffset() != inRHS.getSourceOffset())
1599  return true;
1600  if (getSourcePitch() != inRHS.getSourcePitch())
1601  return true;
1602  if (getDestOffset() != inRHS.getDestOffset())
1603  return true;
1604  if (getDestPitch() != inRHS.getDestPitch())
1605  return true;
1606  return false;
1607 }
1608 
1609 NTV2SegmentedXferInfo & NTV2SegmentedXferInfo::reset (void)
1610 {
1611  mFlags = 0;
1612  mNumSegments = 0;
1613  mElementsPerSegment = 0;
1614  mInitialSrcOffset = 0;
1615  mInitialDstOffset = 0;
1616  mSrcElementsPerRow = 0;
1617  mDstElementsPerRow = 0;
1618  setElementLength(1); // elements == bytes
1619  return *this;
1620 }
1621 
1622 NTV2SegmentedXferInfo & NTV2SegmentedXferInfo::swapSourceAndDestination (void)
1623 {
1624  std::swap(mSrcElementsPerRow, mDstElementsPerRow);
1625  std::swap(mInitialSrcOffset, mInitialDstOffset);
1626  const bool srcNormal(this->isSourceTopDown()), dstNormal(this->isDestTopDown());
1627  setSourceDirection(dstNormal).setDestDirection(srcNormal);
1628  return *this;
1629 }
1630 
1631 
1632 NTV2Buffer::NTV2Buffer (const void * pInUserPointer, const size_t inByteCount)
1633  : fUserSpacePtr (inByteCount ? NTV2Buffer_TO_ULWORD64(pInUserPointer) : 0),
1634  fByteCount (ULWord(pInUserPointer ? inByteCount : 0)),
1635  fFlags (0),
1636  #if defined (AJAMac)
1637  fKernelSpacePtr (0),
1638  fIOMemoryDesc (0),
1639  fIOMemoryMap (0)
1640  #else
1641  //fKernelSpacePtr (0),
1642  fKernelHandle (0)
1643  #endif
1644 {
1645 }
1646 
1647 
1648 NTV2Buffer::NTV2Buffer (const size_t inByteCount)
1649  : fUserSpacePtr (0),
1650  fByteCount (0),
1651  fFlags (0),
1652  #if defined (AJAMac)
1653  fKernelSpacePtr (0),
1654  fIOMemoryDesc (0),
1655  fIOMemoryMap (0)
1656  #else
1657  //fKernelSpacePtr (0),
1658  fKernelHandle (0)
1659  #endif
1660 {
1661  if (inByteCount)
1662  Allocate(inByteCount);
1663 }
1664 
1665 
1666 NTV2Buffer::NTV2Buffer (const NTV2Buffer & inObj)
1667  : fUserSpacePtr (0),
1668  fByteCount (0),
1669  fFlags (0),
1670  #if defined (AJAMac)
1671  fKernelSpacePtr (0),
1672  fIOMemoryDesc (0),
1673  fIOMemoryMap (0)
1674  #else
1675  //fKernelSpacePtr (0),
1676  fKernelHandle (0)
1677  #endif
1678 {
1679  if (Allocate(inObj.GetByteCount()))
1680  SetFrom(inObj);
1681 }
1682 
1683 bool NTV2Buffer::Truncate (const size_t inNewByteCount)
1684 {
1685  if (inNewByteCount == GetByteCount())
1686  return true; // Same size -- done!
1687  if (inNewByteCount > GetByteCount())
1688  return false; // Cannot enlarge -- i.e. can't be greater than my current size
1689  if (!inNewByteCount && IsAllocatedBySDK())
1690  return Deallocate(); // A newByteCount of zero calls Deallocate
1691  fByteCount = ULWord(inNewByteCount);
1692  return true;
1693 }
1694 
1695 NTV2Buffer & NTV2Buffer::operator = (const NTV2Buffer & inRHS)
1696 {
1697  if (&inRHS != this)
1698  {
1699  if (inRHS.IsNULL())
1700  Set (AJA_NULL, 0);
1701  else if (GetByteCount() == inRHS.GetByteCount())
1702  SetFrom(inRHS);
1703  else if (Allocate(inRHS.GetByteCount()))
1704  SetFrom(inRHS);
1705  //else; // Error
1706  }
1707  return *this;
1708 }
1709 
1710 
1711 NTV2Buffer::~NTV2Buffer ()
1712 {
1713  Set (AJA_NULL, 0); // Call 'Set' to delete the array (if I allocated it)
1714 }
1715 
1716 
1717 bool NTV2Buffer::ByteSwap64 (void)
1718 {
1719  uint64_t * pU64s(reinterpret_cast<uint64_t*>(GetHostPointer()));
1720  const size_t loopCount(GetByteCount() / sizeof(uint64_t));
1721  if (IsNULL())
1722  return false;
1723  for (size_t ndx(0); ndx < loopCount; ndx++)
1724  pU64s[ndx] = NTV2EndianSwap64(pU64s[ndx]);
1725  return true;
1726 }
1727 
1728 
1729 bool NTV2Buffer::ByteSwap32 (void)
1730 {
1731  uint32_t * pU32s(reinterpret_cast<uint32_t*>(GetHostPointer()));
1732  const size_t loopCount(GetByteCount() / sizeof(uint32_t));
1733  if (IsNULL())
1734  return false;
1735  for (size_t ndx(0); ndx < loopCount; ndx++)
1736  pU32s[ndx] = NTV2EndianSwap32(pU32s[ndx]);
1737  return true;
1738 }
1739 
1740 
1741 bool NTV2Buffer::ByteSwap16 (void)
1742 {
1743  uint16_t * pU16s(reinterpret_cast<uint16_t*>(GetHostPointer()));
1744  const size_t loopCount(GetByteCount() / sizeof(uint16_t));
1745  if (IsNULL())
1746  return false;
1747  for (size_t ndx(0); ndx < loopCount; ndx++)
1748  pU16s[ndx] = NTV2EndianSwap16(pU16s[ndx]);
1749  return true;
1750 }
1751 
1752 
1753 bool NTV2Buffer::Set (const void * pInUserPointer, const size_t inByteCount)
1754 {
1755  Deallocate();
1756  fUserSpacePtr = inByteCount ? NTV2Buffer_TO_ULWORD64(pInUserPointer) : 0;
1757  fByteCount = ULWord(pInUserPointer ? inByteCount : 0);
1758  // Return true only if both UserPointer and ByteCount are non-zero, or both are zero.
1759  return (pInUserPointer && inByteCount) || (!pInUserPointer && !inByteCount);
1760 }
1761 
1762 
1763 bool NTV2Buffer::SetAndFill (const void * pInUserPointer, const size_t inByteCount, const UByte inValue)
1764 {
1765  return Set(pInUserPointer, inByteCount) && Fill(inValue);
1766 }
1767 
1768 
1769 bool NTV2Buffer::Allocate (const size_t inByteCount, const bool inPageAligned)
1770 {
1771  if (GetByteCount() && fFlags & NTV2Buffer_ALLOCATED) // If already was Allocated
1772  if (inByteCount == GetByteCount()) // If same byte count
1773  {
1774  Fill(UByte(0)); // Zero it...
1775  return true; // ...and return true
1776  }
1777 
1778  bool result(Set(AJA_NULL, 0)); // Jettison existing buffer (if any)
1779  if (inByteCount)
1780  { // Allocate the byte array, and call Set...
1781  UByte * pBuffer(AJA_NULL);
1782  result = false;
1783  if (inPageAligned)
1784  pBuffer = reinterpret_cast<UByte*>(AJAMemory::AllocateAligned(inByteCount, DefaultPageSize()));
1785  else
1786  try
1787  {pBuffer = new UByte[inByteCount];}
1788  catch (const std::bad_alloc &)
1789  {pBuffer = AJA_NULL;}
1790  if (pBuffer && Set(pBuffer, inByteCount))
1791  { // SDK owns this memory -- set NTV2Buffer_ALLOCATED bit -- I'm responsible for deleting
1792  result = true;
1793  fFlags |= NTV2Buffer_ALLOCATED;
1794  if (inPageAligned)
1795  fFlags |= NTV2Buffer_PAGE_ALIGNED; // Set "page aligned" flag
1796  Fill(UByte(0)); // Zero it
1797  }
1798  } // if requested size is non-zero
1799  return result;
1800 }
1801 
1802 
1803 bool NTV2Buffer::Deallocate (void)
1804 {
1805  if (IsAllocatedBySDK())
1806  {
1807  if (!IsNULL())
1808  {
1809  if (IsPageAligned())
1810  {
1811  AJAMemory::FreeAligned(GetHostPointer());
1812  fFlags &= ~NTV2Buffer_PAGE_ALIGNED;
1813  }
1814  else
1815  delete [] reinterpret_cast<UByte*>(GetHostPointer());
1816  }
1817  fUserSpacePtr = 0;
1818  fByteCount = 0;
1819  fFlags &= ~NTV2Buffer_ALLOCATED;
1820  }
1821  return true;
1822 }
1823 
1824 
1825 void * NTV2Buffer::GetHostAddress (const ULWord inByteOffset, const bool inFromEnd) const
1826 {
1827  if (IsNULL())
1828  return AJA_NULL;
1829  if (inByteOffset >= GetByteCount())
1830  return AJA_NULL;
1831  UByte * pBytes (reinterpret_cast<UByte*>(GetHostPointer()));
1832  if (inFromEnd)
1833  pBytes += GetByteCount() - inByteOffset;
1834  else
1835  pBytes += inByteOffset;
1836  return pBytes;
1837 }
1838 
1839 
1840 bool NTV2Buffer::SetFrom (const NTV2Buffer & inBuffer)
1841 {
1842  if (inBuffer.IsNULL())
1843  return false; // NULL or empty
1844  if (IsNULL())
1845  return false; // I am NULL or empty
1846  if (inBuffer.GetByteCount() == GetByteCount() && inBuffer.GetHostPointer() == GetHostPointer())
1847  return true; // Same buffer
1848 
1849  size_t bytesToCopy(inBuffer.GetByteCount());
1850  if (bytesToCopy > GetByteCount())
1851  bytesToCopy = GetByteCount();
1852  ::memcpy (GetHostPointer(), inBuffer.GetHostPointer(), bytesToCopy);
1853  return true;
1854 }
1855 
1856 
1857 bool NTV2Buffer::CopyFrom (const void * pInSrcBuffer, const ULWord inByteCount)
1858 {
1859  if (!inByteCount)
1860  return Set (AJA_NULL, 0); // Zero bytes
1861  if (!pInSrcBuffer)
1862  return false; // NULL src ptr
1863  if (!Allocate (inByteCount))
1864  return false; // Resize failed
1865  ::memcpy (GetHostPointer(), pInSrcBuffer, inByteCount);
1866  return true;
1867 }
1868 
1869 
1870 bool NTV2Buffer::CopyFrom (const NTV2Buffer & inBuffer,
1871  const ULWord inSrcByteOffset, const ULWord inDstByteOffset, const ULWord inByteCount)
1872 {
1873  if (inBuffer.IsNULL() || IsNULL())
1874  return false; // NULL or empty
1875  if (inSrcByteOffset + inByteCount > inBuffer.GetByteCount())
1876  return false; // Past end of src
1877  if (inDstByteOffset + inByteCount > GetByteCount())
1878  return false; // Past end of me
1879 
1880  const UByte * pSrc (inBuffer);
1881  pSrc += inSrcByteOffset;
1882 
1883  UByte * pDst (*this);
1884  pDst += inDstByteOffset;
1885 
1886  ::memcpy (pDst, pSrc, inByteCount);
1887  return true;
1888 }
1889 
1890 
1891 bool NTV2Buffer::CopyFrom (const NTV2Buffer & inSrcBuffer, const NTV2SegmentedXferInfo & inXferInfo)
1892 {
1893  if (!inXferInfo.isValid() || inSrcBuffer.IsNULL() || IsNULL())
1894  return false;
1895 
1896  // Copy every segment...
1897  LWord srcOffset (LWord(inXferInfo.getSourceOffset() * inXferInfo.getElementLength()));
1898  LWord dstOffset (LWord(inXferInfo.getDestOffset() * inXferInfo.getElementLength()));
1899  LWord srcPitch (LWord(inXferInfo.getSourcePitch() * inXferInfo.getElementLength()));
1900  LWord dstPitch (LWord(inXferInfo.getDestPitch() * inXferInfo.getElementLength()));
1901  const LWord bytesPerSeg (inXferInfo.getSegmentLength() * inXferInfo.getElementLength());
1902  if (inXferInfo.isSourceBottomUp())
1903  srcPitch = 0 - srcPitch;
1904  if (inXferInfo.isDestBottomUp())
1905  dstPitch = 0 - dstPitch;
1906  for (ULWord segNdx(0); segNdx < inXferInfo.getSegmentCount(); segNdx++)
1907  {
1908  const void * pSrc (inSrcBuffer.GetHostAddress(srcOffset));
1909  void * pDst (GetHostAddress(dstOffset));
1910  if (!pSrc) return false;
1911  if (!pDst) return false;
1912  if (srcOffset + bytesPerSeg > LWord(inSrcBuffer.GetByteCount()))
1913  return false; // memcpy will read past end of srcBuffer
1914  if (dstOffset + bytesPerSeg > LWord(GetByteCount()))
1915  return false; // memcpy will write past end of me
1916  ::memcpy (pDst, pSrc, size_t(bytesPerSeg));
1917  srcOffset += srcPitch; // Bump src offset
1918  dstOffset += dstPitch; // Bump dst offset
1919  } // for each segment
1920  return true;
1921 }
1922 
1923 bool NTV2Buffer::SetFromHexString (const string & inStr)
1924 {
1925  string str(inStr);
1926 
1927  // Remove all whitespace...
1928  const string newline("\n"), tab("\t");
1929  aja::replace(str, newline, string());
1930  aja::replace(str, tab, string());
1931  aja::upper(str);
1932 
1933  // Fail if any non-hex found...
1934  for (size_t ndx(0); ndx < str.size(); ndx++)
1935  if (!aja::is_hex_digit(str.at(ndx)))
1936  return false;
1937 
1938  if (str.size() & 1)
1939  return false; // Remaining length must be even
1940  if (!Allocate(str.size() / 2))
1941  return false; // Resize failed
1942 
1943  // Decode and copy in the data...
1944  for (size_t srcNdx(0), dstNdx(0); srcNdx < str.size(); srcNdx += 2)
1945  U8(int(dstNdx++)) = uint8_t(aja::stoul (str.substr(srcNdx,2), AJA_NULL, 16));
1946 
1947  return true;
1948 }
1949 
1950 bool NTV2Buffer::SwapWith (NTV2Buffer & inBuffer)
1951 {
1952  if (inBuffer.IsNULL ())
1953  return false; // NULL or empty
1954  if (IsNULL ())
1955  return false; // I am NULL or empty
1956  if (inBuffer.GetByteCount () != GetByteCount ())
1957  return false; // Different sizes
1958  if (fFlags != inBuffer.fFlags)
1959  return false; // Flags mismatch
1960  if (inBuffer.GetHostPointer () == GetHostPointer ())
1961  return true; // Same buffer
1962 
1963  ULWord64 tmp = fUserSpacePtr;
1964  fUserSpacePtr = inBuffer.fUserSpacePtr;
1965  inBuffer.fUserSpacePtr = tmp;
1966  return true;
1967 }
1968 
1969 set<ULWord> & NTV2Buffer::FindAll (set<ULWord> & outOffsets, const NTV2Buffer & inValue) const
1970 {
1971  outOffsets.clear();
1972  if (IsNULL())
1973  return outOffsets; // NULL buffer, return "no matches"
1974  if (inValue.IsNULL())
1975  return outOffsets; // NULL buffer, return "no matches"
1976  const ULWord srchByteCount(inValue.GetByteCount());
1977  if (GetByteCount() < srchByteCount)
1978  return outOffsets; // I'm smaller than the search data, return "no matches"
1979 
1980  const ULWord maxOffset(GetByteCount() - srchByteCount); // Don't search past here
1981  const uint8_t * pSrchData (inValue); // Pointer to search data
1982  const uint8_t * pMyData (*this); // Pointer to where search starts in me
1983  ULWord offset(0); // Search starts at this byte offset
1984  do
1985  {
1986  if (!::memcmp(pMyData, pSrchData, srchByteCount))
1987  outOffsets.insert(offset); // Record byte offset of match
1988  pMyData++; // Bump search pointer
1989  offset++; // Bump search byte offset
1990  } while (offset < maxOffset);
1991  return outOffsets;
1992 }
1993 
1994 bool NTV2Buffer::IsContentEqual (const NTV2Buffer & inBuffer, const ULWord inByteOffset, const ULWord inByteCount) const
1995 {
1996  if (IsNULL() || inBuffer.IsNULL())
1997  return false; // Buffer(s) are NULL/empty
1998  if (inBuffer.GetByteCount() != GetByteCount())
1999  return false; // Buffers are different sizes
2000 
2001  ULWord totalBytes(GetByteCount());
2002  if (inByteOffset >= totalBytes)
2003  return false; // Bad offset
2004 
2005  totalBytes -= inByteOffset;
2006 
2007  ULWord byteCount(inByteCount);
2008  if (byteCount > totalBytes)
2009  byteCount = totalBytes;
2010 
2011  if (inBuffer.GetHostPointer() == GetHostPointer())
2012  return true; // Same buffer
2013 
2014  const UByte * pByte1 (*this);
2015  const UByte * pByte2 (inBuffer);
2016  pByte1 += inByteOffset;
2017  pByte2 += inByteOffset;
2018  #if !defined(NTV2BUFFER_NO_MEMCMP)
2019  return ::memcmp (pByte1, pByte2, byteCount) == 0;
2020  #else // NTV2BUFFER_NO_MEMCMP
2021  ULWord offset(inByteOffset);
2022  while (byteCount)
2023  {
2024  if (*pByte1 != *pByte2)
2025  {
2026  cerr << "## ERROR: IsContentEqual: miscompare at offset " << xHEX0N(offset,8)
2027  << " (" << DEC(offset) << "): " << xHEX0N(UWord(*pByte1),2) << " != "
2028  << xHEX0N(UWord(*pByte2),2) << ", " << xHEX0N(byteCount,8) << " ("
2029  << DEC(byteCount) << ") bytes left to compare" << endl;
2030  return false;
2031  }
2032  pByte1++; pByte2++;
2033  byteCount--;
2034  offset++;
2035  }
2036  return true;
2037  #endif // NTV2BUFFER_NO_MEMCMP
2038 }
2039 
2040 bool NTV2Buffer::NextDifference (const NTV2Buffer & inBuffer, ULWord & byteOffset) const
2041 {
2042  if (byteOffset == 0xFFFFFFFF)
2043  return false; // bad offset
2044  if (IsNULL() || inBuffer.IsNULL())
2045  return false; // NULL or empty buffers
2046  if (inBuffer.GetByteCount() != GetByteCount())
2047  return false; // Different byte counts
2048  if (inBuffer.GetHostPointer() == GetHostPointer())
2049  {byteOffset = 0xFFFFFFFF; return true;} // Same buffer
2050 
2051  ULWord totalBytesToCompare(GetByteCount());
2052  if (byteOffset >= totalBytesToCompare)
2053  return false; // Bad offset
2054  totalBytesToCompare -= byteOffset;
2055 
2056  const UByte * pByte1 (*this);
2057  const UByte * pByte2 (inBuffer);
2058  while (totalBytesToCompare)
2059  {
2060  if (pByte1[byteOffset] != pByte2[byteOffset])
2061  return true;
2062  totalBytesToCompare--;
2063  byteOffset++;
2064  }
2065  byteOffset = 0xFFFFFFFF;
2066  return true;
2067 }
2068 
2069 bool NTV2Buffer::GetRingChangedByteRange (const NTV2Buffer & inBuffer, ULWord & outByteOffsetFirst, ULWord & outByteOffsetLast) const
2070 {
2071  outByteOffsetFirst = outByteOffsetLast = GetByteCount ();
2072  if (IsNULL () || inBuffer.IsNULL ())
2073  return false; // NULL or empty
2074  if (inBuffer.GetByteCount () != GetByteCount ())
2075  return false; // Different byte counts
2076  if (inBuffer.GetHostPointer () == GetHostPointer ())
2077  return true; // Same buffer
2078  if (GetByteCount() < 3)
2079  return false; // Too small
2080 
2081  const UByte * pByte1 (reinterpret_cast <const UByte *> (GetHostPointer()));
2082  const UByte * pByte2 (reinterpret_cast <const UByte *> (inBuffer.GetHostPointer()));
2083 
2084  outByteOffsetFirst = 0;
2085  while (outByteOffsetFirst < GetByteCount())
2086  {
2087  if (*pByte1 != *pByte2)
2088  break;
2089  pByte1++;
2090  pByte2++;
2091  outByteOffsetFirst++;
2092  }
2093  if (outByteOffsetFirst == 0)
2094  {
2095  // Wrap case -- look for first match...
2096  while (outByteOffsetFirst < GetByteCount())
2097  {
2098  if (*pByte1 == *pByte2)
2099  break;
2100  pByte1++;
2101  pByte2++;
2102  outByteOffsetFirst++;
2103  }
2104  if (outByteOffsetFirst < GetByteCount())
2105  outByteOffsetFirst--;
2106  }
2107  if (outByteOffsetFirst == GetByteCount())
2108  return true; // Identical --- outByteOffsetFirst == outByteOffsetLast == GetByteCount()
2109 
2110  // Now scan from the end...
2111  pByte1 = reinterpret_cast <const UByte *> (GetHostPointer());
2112  pByte2 = reinterpret_cast <const UByte *> (inBuffer.GetHostPointer());
2113  pByte1 += GetByteCount () - 1; // Point to last byte
2114  pByte2 += GetByteCount () - 1;
2115  while (--outByteOffsetLast)
2116  {
2117  if (*pByte1 != *pByte2)
2118  break;
2119  pByte1--;
2120  pByte2--;
2121  }
2122  if (outByteOffsetLast == (GetByteCount() - 1))
2123  {
2124  // Wrap case -- look for first match...
2125  while (outByteOffsetLast)
2126  {
2127  if (*pByte1 == *pByte2)
2128  break;
2129  pByte1--;
2130  pByte2--;
2131  outByteOffsetLast--;
2132  }
2133  if (outByteOffsetLast < GetByteCount())
2134  outByteOffsetLast++;
2135  if (outByteOffsetLast <= outByteOffsetFirst)
2136  cerr << "## WARNING: GetRingChangedByteRange: last " << outByteOffsetLast << " <= first " << outByteOffsetFirst << " in wrap condition" << endl;
2137  const ULWord tmp (outByteOffsetLast);
2138  outByteOffsetLast = outByteOffsetFirst;
2139  outByteOffsetFirst = tmp;
2140  if (outByteOffsetLast >= outByteOffsetFirst)
2141  cerr << "## WARNING: GetRingChangedByteRange: last " << outByteOffsetLast << " >= first " << outByteOffsetFirst << " in wrap condition" << endl;
2142  }
2143  return true;
2144 
2145 } // GetRingChangedByteRange
2146 
2147 
2148 static size_t gDefaultPageSize (AJA_PAGE_SIZE);
2149 
2150 size_t NTV2Buffer::DefaultPageSize (void)
2151 {
2152  return gDefaultPageSize;
2153 }
2154 
2155 bool NTV2Buffer::SetDefaultPageSize (const size_t inNewSize)
2156 {
2157  const bool result (inNewSize && (!(inNewSize & (inNewSize - 1))));
2158  if (result)
2159  gDefaultPageSize = inNewSize;
2160  return result;
2161 }
2162 
2163 size_t NTV2Buffer::HostPageSize (void)
2164 {
2165 #if defined(MSWindows) || defined(AJABareMetal)
2166  return AJA_PAGE_SIZE;
2167 #else
2168  return size_t(::getpagesize());
2169 #endif
2170 }
2171 
2172 
2173 FRAME_STAMP::FRAME_STAMP ()
2174  : acHeader (NTV2_TYPE_ACFRAMESTAMP, sizeof(FRAME_STAMP)),
2175  acFrameTime (0),
2176  acRequestedFrame (0),
2177  acAudioClockTimeStamp (0),
2178  acAudioExpectedAddress (0),
2179  acAudioInStartAddress (0),
2180  acAudioInStopAddress (0),
2181  acAudioOutStopAddress (0),
2182  acAudioOutStartAddress (0),
2183  acTotalBytesTransferred (0),
2184  acStartSample (0),
2185  acTimeCodes (NTV2_MAX_NUM_TIMECODE_INDEXES * sizeof (NTV2_RP188)),
2186  acCurrentTime (0),
2187  acCurrentFrame (0),
2188  acCurrentFrameTime (0),
2189  acAudioClockCurrentTime (0),
2190  acCurrentAudioExpectedAddress (0),
2191  acCurrentAudioStartAddress (0),
2192  acCurrentFieldCount (0),
2193  acCurrentLineCount (0),
2194  acCurrentReps (0),
2195  acCurrentUserCookie (0),
2196  acFrame (0),
2197  acRP188 ()
2198 {
2199  NTV2_ASSERT_STRUCT_VALID;
2200 }
2201 
2202 
2203 FRAME_STAMP::FRAME_STAMP (const FRAME_STAMP & inObj)
2204  : acHeader (inObj.acHeader),
2205  acFrameTime (inObj.acFrameTime),
2206  acRequestedFrame (inObj.acRequestedFrame),
2207  acAudioClockTimeStamp (inObj.acAudioClockTimeStamp),
2208  acAudioExpectedAddress (inObj.acAudioExpectedAddress),
2209  acAudioInStartAddress (inObj.acAudioInStartAddress),
2210  acAudioInStopAddress (inObj.acAudioInStopAddress),
2211  acAudioOutStopAddress (inObj.acAudioOutStopAddress),
2212  acAudioOutStartAddress (inObj.acAudioOutStartAddress),
2213  acTotalBytesTransferred (inObj.acTotalBytesTransferred),
2214  acStartSample (inObj.acStartSample),
2215  acCurrentTime (inObj.acCurrentTime),
2216  acCurrentFrame (inObj.acCurrentFrame),
2217  acCurrentFrameTime (inObj.acCurrentFrameTime),
2218  acAudioClockCurrentTime (inObj.acAudioClockCurrentTime),
2219  acCurrentAudioExpectedAddress (inObj.acCurrentAudioExpectedAddress),
2220  acCurrentAudioStartAddress (inObj.acCurrentAudioStartAddress),
2221  acCurrentFieldCount (inObj.acCurrentFieldCount),
2222  acCurrentLineCount (inObj.acCurrentLineCount),
2223  acCurrentReps (inObj.acCurrentReps),
2224  acCurrentUserCookie (inObj.acCurrentUserCookie),
2225  acFrame (inObj.acFrame),
2226  acRP188 (inObj.acRP188),
2227  acTrailer (inObj.acTrailer)
2228 {
2229  acTimeCodes.SetFrom (inObj.acTimeCodes);
2230 }
2231 
2232 
2233 FRAME_STAMP::~FRAME_STAMP ()
2234 {
2235 }
2236 
2237 
2238 bool FRAME_STAMP::GetInputTimeCodes (NTV2TimeCodeList & outValues) const
2239 {
2240  NTV2_ASSERT_STRUCT_VALID;
2241  ULWord numRP188s (acTimeCodes.GetByteCount () / sizeof (NTV2_RP188));
2242  const NTV2_RP188 * pArray (reinterpret_cast <const NTV2_RP188 *> (acTimeCodes.GetHostPointer ()));
2243  outValues.clear ();
2244  if (!pArray)
2245  return false; // No 'acTimeCodes' array!
2246 
2247  if (numRP188s > NTV2_MAX_NUM_TIMECODE_INDEXES)
2248  numRP188s = NTV2_MAX_NUM_TIMECODE_INDEXES; // clamp to this max number
2249 
2250  for (ULWord ndx (0); ndx < numRP188s; ndx++)
2251  outValues << pArray [ndx];
2252 
2253  return true;
2254 }
2255 
2256 
2257 bool FRAME_STAMP::GetInputTimeCode (NTV2_RP188 & outTimeCode, const NTV2TCIndex inTCIndex) const
2258 {
2259  NTV2_ASSERT_STRUCT_VALID;
2260  ULWord numRP188s (acTimeCodes.GetByteCount () / sizeof (NTV2_RP188));
2261  const NTV2_RP188 * pArray (reinterpret_cast <const NTV2_RP188 *> (acTimeCodes.GetHostPointer ()));
2262  outTimeCode.Set (); // invalidate
2263  if (!pArray)
2264  return false; // No 'acTimeCodes' array!
2265  if (numRP188s > NTV2_MAX_NUM_TIMECODE_INDEXES)
2266  numRP188s = NTV2_MAX_NUM_TIMECODE_INDEXES; // clamp to this max number
2267  if (!NTV2_IS_VALID_TIMECODE_INDEX (inTCIndex))
2268  return false;
2269 
2270  outTimeCode = pArray [inTCIndex];
2271  return true;
2272 }
2273 
2274 
2275 bool FRAME_STAMP::GetInputTimeCodes (NTV2TimeCodes & outTimeCodes, const NTV2Channel inSDIInput, const bool inValidOnly) const
2276 {
2277  NTV2_ASSERT_STRUCT_VALID;
2278  outTimeCodes.clear();
2279 
2280  if (!NTV2_IS_VALID_CHANNEL(inSDIInput))
2281  return false; // Bad SDI input
2282 
2283  NTV2TimeCodeList allTCs;
2284  if (!GetInputTimeCodes(allTCs))
2285  return false; // GetInputTimeCodes failed
2286 
2287  const NTV2TCIndexes tcIndexes (GetTCIndexesForSDIInput(inSDIInput));
2288  for (NTV2TCIndexesConstIter iter(tcIndexes.begin()); iter != tcIndexes.end(); ++iter)
2289  {
2290  const NTV2TCIndex tcIndex(*iter);
2291  NTV2_ASSERT(NTV2_IS_VALID_TIMECODE_INDEX(tcIndex));
2292  const NTV2_RP188 tc(allTCs.at(tcIndex));
2293  if (!inValidOnly)
2294  outTimeCodes[tcIndex] = tc;
2295  else if (tc.IsValid())
2296  outTimeCodes[tcIndex] = tc;
2297  }
2298  return true;
2299 }
2300 
2301 
2302 bool FRAME_STAMP::GetSDIInputStatus(NTV2SDIInputStatus & outStatus, const UWord inSDIInputIndex0) const
2303 {
2304  NTV2_ASSERT_STRUCT_VALID;
2305  (void)outStatus;
2306  (void)inSDIInputIndex0;
2307  return true;
2308 }
2309 
2310 bool FRAME_STAMP::SetInputTimecode (const NTV2TCIndex inTCNdx, const NTV2_RP188 & inTimecode)
2311 {
2312  ULWord numRP188s (acTimeCodes.GetByteCount() / sizeof(NTV2_RP188));
2313  NTV2_RP188 * pArray (reinterpret_cast<NTV2_RP188*>(acTimeCodes.GetHostPointer()));
2314  if (!pArray || !numRP188s)
2315  return false; // No 'acTimeCodes' array!
2316 
2317  if (numRP188s > NTV2_MAX_NUM_TIMECODE_INDEXES)
2318  numRP188s = NTV2_MAX_NUM_TIMECODE_INDEXES; // clamp to this max number
2319  if (ULWord(inTCNdx) >= numRP188s)
2320  return false; // Past end
2321 
2322  pArray[inTCNdx] = inTimecode; // Write the new value
2323  return true; // Success!
2324 }
2325 
2326 
2327 FRAME_STAMP & FRAME_STAMP::operator = (const FRAME_STAMP & inRHS)
2328 {
2329  if (this != &inRHS)
2330  {
2331  acTimeCodes = inRHS.acTimeCodes;
2332  acHeader = inRHS.acHeader;
2333  acFrameTime = inRHS.acFrameTime;
2334  acRequestedFrame = inRHS.acRequestedFrame;
2335  acAudioClockTimeStamp = inRHS.acAudioClockTimeStamp;
2336  acAudioExpectedAddress = inRHS.acAudioExpectedAddress;
2337  acAudioInStartAddress = inRHS.acAudioInStartAddress;
2338  acAudioInStopAddress = inRHS.acAudioInStopAddress;
2339  acAudioOutStopAddress = inRHS.acAudioOutStopAddress;
2340  acAudioOutStartAddress = inRHS.acAudioOutStartAddress;
2341  acTotalBytesTransferred = inRHS.acTotalBytesTransferred;
2342  acStartSample = inRHS.acStartSample;
2343  acCurrentTime = inRHS.acCurrentTime;
2344  acCurrentFrame = inRHS.acCurrentFrame;
2345  acCurrentFrameTime = inRHS.acCurrentFrameTime;
2346  acAudioClockCurrentTime = inRHS.acAudioClockCurrentTime;
2347  acCurrentAudioExpectedAddress = inRHS.acCurrentAudioExpectedAddress;
2348  acCurrentAudioStartAddress = inRHS.acCurrentAudioStartAddress;
2349  acCurrentFieldCount = inRHS.acCurrentFieldCount;
2350  acCurrentLineCount = inRHS.acCurrentLineCount;
2351  acCurrentReps = inRHS.acCurrentReps;
2352  acCurrentUserCookie = inRHS.acCurrentUserCookie;
2353  acFrame = inRHS.acFrame;
2354  acRP188 = inRHS.acRP188;
2355  acTrailer = inRHS.acTrailer;
2356  }
2357  return *this;
2358 }
2359 
2360 
2361 bool FRAME_STAMP::SetFrom (const FRAME_STAMP_STRUCT & inOldStruct)
2362 {
2363  NTV2_ASSERT_STRUCT_VALID;
2364  //acCrosspoint = inOldStruct.channelSpec;
2365  acFrameTime = inOldStruct.frameTime;
2366  acRequestedFrame = inOldStruct.frame;
2367  acAudioClockTimeStamp = inOldStruct.audioClockTimeStamp;
2368  acAudioExpectedAddress = inOldStruct.audioExpectedAddress;
2369  acAudioInStartAddress = inOldStruct.audioInStartAddress;
2370  acAudioInStopAddress = inOldStruct.audioInStopAddress;
2371  acAudioOutStopAddress = inOldStruct.audioOutStopAddress;
2372  acAudioOutStartAddress = inOldStruct.audioOutStartAddress;
2373  acTotalBytesTransferred = inOldStruct.bytesRead;
2374  acStartSample = inOldStruct.startSample;
2375  acCurrentTime = inOldStruct.currentTime;
2376  acCurrentFrame = inOldStruct.currentFrame;
2377  acCurrentFrameTime = inOldStruct.currentFrameTime;
2378  acAudioClockCurrentTime = inOldStruct.audioClockCurrentTime;
2379  acCurrentAudioExpectedAddress = inOldStruct.currentAudioExpectedAddress;
2380  acCurrentAudioStartAddress = inOldStruct.currentAudioStartAddress;
2381  acCurrentFieldCount = inOldStruct.currentFieldCount;
2382  acCurrentLineCount = inOldStruct.currentLineCount;
2383  acCurrentReps = inOldStruct.currentReps;
2384  acCurrentUserCookie = inOldStruct.currenthUser;
2385  acRP188 = NTV2_RP188 (inOldStruct.currentRP188);
2386  if (!acTimeCodes.IsNULL() && acTimeCodes.GetByteCount () >= sizeof (NTV2_RP188))
2387  {
2388  NTV2_RP188 * pTimecodes (reinterpret_cast <NTV2_RP188 *> (acTimeCodes.GetHostPointer ()));
2389  NTV2_ASSERT (pTimecodes);
2390  NTV2_ASSERT (NTV2_TCINDEX_DEFAULT == 0);
2391  pTimecodes [NTV2_TCINDEX_DEFAULT] = acRP188;
2392  }
2393  return true;
2394 }
2395 
2396 
2397 bool FRAME_STAMP::CopyTo (FRAME_STAMP_STRUCT & outOldStruct) const
2398 {
2399  NTV2_ASSERT_STRUCT_VALID;
2400  outOldStruct.frameTime = acFrameTime;
2401  outOldStruct.frame = acRequestedFrame;
2402  outOldStruct.audioClockTimeStamp = acAudioClockTimeStamp;
2403  outOldStruct.audioExpectedAddress = acAudioExpectedAddress;
2404  outOldStruct.audioInStartAddress = acAudioInStartAddress;
2405  outOldStruct.audioInStopAddress = acAudioInStopAddress;
2406  outOldStruct.audioOutStopAddress = acAudioOutStopAddress;
2407  outOldStruct.audioOutStartAddress = acAudioOutStartAddress;
2408  outOldStruct.bytesRead = acTotalBytesTransferred;
2409  outOldStruct.startSample = acStartSample;
2410  outOldStruct.currentTime = acCurrentTime;
2411  outOldStruct.currentFrame = acCurrentFrame;
2412  outOldStruct.currentFrameTime = acCurrentFrameTime;
2413  outOldStruct.audioClockCurrentTime = acAudioClockCurrentTime;
2414  outOldStruct.currentAudioExpectedAddress = acCurrentAudioExpectedAddress;
2415  outOldStruct.currentAudioStartAddress = acCurrentAudioStartAddress;
2416  outOldStruct.currentFieldCount = acCurrentFieldCount;
2417  outOldStruct.currentLineCount = acCurrentLineCount;
2418  outOldStruct.currentReps = acCurrentReps;
2419  outOldStruct.currenthUser = ULWord(acCurrentUserCookie);
2420  outOldStruct.currentRP188 = acRP188;
2421  // Ticket 3367 -- Mark Gilbert of Gallery UK reports that after updating from AJA Retail Software 10.5 to 14.0,
2422  // their QuickTime app stopped receiving timecode during capture. Turns out the QuickTime components use the new
2423  // AutoCirculate APIs, but internally still use the old FRAME_STAMP_STRUCT for frame info, including timecode...
2424  // ...and only use the "currentRP188" field for the "retail" timecode.
2425  // Sadly, this FRAME_STAMP-to-FRAME_STAMP_STRUCT function historically only set "currentRP188" from the deprecated
2426  // (and completely unused) "acRP188" field, when it really should've been using the acTimeCodes[NTV2_TCINDEX_DEFAULT]
2427  // value all along...
2428  if (!acTimeCodes.IsNULL()) // If there's an acTimeCodes buffer...
2429  if (acTimeCodes.GetByteCount() >= sizeof(NTV2_RP188)) // ...and it has at least one timecode value...
2430  {
2431  const NTV2_RP188 * pDefaultTC (reinterpret_cast<const NTV2_RP188*>(acTimeCodes.GetHostPointer()));
2432  if (pDefaultTC)
2433  outOldStruct.currentRP188 = pDefaultTC[NTV2_TCINDEX_DEFAULT]; // Stuff the "default" (retail) timecode into "currentRP188".
2434  }
2435  return true;
2436 }
2437 
2438 
2439 string FRAME_STAMP::operator [] (const unsigned inIndexNum) const
2440 {
2441  ostringstream oss;
2442  NTV2_RP188 rp188;
2443  if (GetInputTimeCode (rp188, NTV2TimecodeIndex (inIndexNum)))
2444  {
2445  if (rp188.IsValid())
2446  {
2447  CRP188 foo (rp188);
2448  oss << foo;
2449  }
2450  else
2451  oss << "---";
2452  }
2453  else if (NTV2_IS_VALID_TIMECODE_INDEX (inIndexNum))
2454  oss << "---";
2455  return oss.str();
2456 }
2457 
2458 
2459 NTV2SDIInStatistics::NTV2SDIInStatistics()
2460  : mHeader(NTV2_TYPE_SDISTATS, sizeof(NTV2SDIInStatistics)),
2461  mInStatistics(NTV2_MAX_NUM_CHANNELS * sizeof(NTV2SDIInputStatus))
2462 {
2463  Clear();
2464  NTV2_ASSERT_STRUCT_VALID;
2465 }
2466 
2467 void NTV2SDIInStatistics::Clear(void)
2468 {
2469  NTV2_ASSERT_STRUCT_VALID;
2470  if (mInStatistics.IsNULL())
2471  return;
2472  NTV2SDIInputStatus * pArray(reinterpret_cast <NTV2SDIInputStatus *> (mInStatistics.GetHostPointer()));
2473  for (int i = 0; i < NTV2_MAX_NUM_CHANNELS; i++)
2474  pArray[i].Clear();
2475 }
2476 
2477 bool NTV2SDIInStatistics::GetSDIInputStatus(NTV2SDIInputStatus & outStatus, const UWord inSDIInputIndex0)
2478 {
2479  NTV2_ASSERT_STRUCT_VALID;
2480  const ULWord numElements(mInStatistics.GetByteCount() / sizeof(NTV2SDIInputStatus));
2481  const NTV2SDIInputStatus * pArray(reinterpret_cast <const NTV2SDIInputStatus *> (mInStatistics.GetHostPointer()));
2482  outStatus.Clear();
2483  if (!pArray)
2484  return false;
2485  if (numElements != 8)
2486  return false;
2487  if (inSDIInputIndex0 >= numElements)
2488  return false;
2489  outStatus = pArray[inSDIInputIndex0];
2490  return true;
2491 }
2492 
2493 NTV2SDIInputStatus & NTV2SDIInStatistics::operator [] (const size_t inSDIInputIndex0)
2494 {
2495  NTV2_ASSERT_STRUCT_VALID;
2496  static NTV2SDIInputStatus dummy;
2497  const ULWord numElements(mInStatistics.GetByteCount() / sizeof(NTV2SDIInputStatus));
2498  NTV2SDIInputStatus * pArray(reinterpret_cast<NTV2SDIInputStatus*>(mInStatistics.GetHostPointer()));
2499  if (!pArray)
2500  return dummy;
2501  if (numElements != 8)
2502  return dummy;
2503  if (inSDIInputIndex0 >= numElements)
2504  return dummy;
2505  return pArray[inSDIInputIndex0];
2506 }
2507 
2508 std::ostream & NTV2SDIInStatistics::Print(std::ostream & inOutStream) const
2509 {
2510  NTV2_ASSERT_STRUCT_VALID;
2511  inOutStream << mHeader << ", " << mInStatistics << ", " << mTrailer; return inOutStream;
2512 }
2513 
2514 
2515 AUTOCIRCULATE_TRANSFER_STATUS::AUTOCIRCULATE_TRANSFER_STATUS ()
2516  : acHeader (NTV2_TYPE_ACXFERSTATUS, sizeof (AUTOCIRCULATE_TRANSFER_STATUS)),
2517  acState (NTV2_AUTOCIRCULATE_DISABLED),
2518  acTransferFrame (0),
2519  acBufferLevel (0),
2520  acFramesProcessed (0),
2521  acFramesDropped (0),
2522  acFrameStamp (),
2523  acAudioTransferSize (0),
2524  acAudioStartSample (0),
2525  acAncTransferSize (0),
2526  acAncField2TransferSize (0)
2527  //acTrailer ()
2528 {
2529  NTV2_ASSERT_STRUCT_VALID;
2530 }
2531 
2532 
2533 AUTOCIRCULATE_STATUS::AUTOCIRCULATE_STATUS (const NTV2Crosspoint inCrosspoint)
2534  : acHeader (NTV2_TYPE_ACSTATUS, sizeof (AUTOCIRCULATE_STATUS)),
2535  acCrosspoint (inCrosspoint),
2536  acState (NTV2_AUTOCIRCULATE_DISABLED),
2537  acStartFrame (0),
2538  acEndFrame (0),
2539  acActiveFrame (0),
2540  acRDTSCStartTime (0),
2541  acAudioClockStartTime (0),
2542  acRDTSCCurrentTime (0),
2543  acAudioClockCurrentTime (0),
2544  acFramesProcessed (0),
2545  acFramesDropped (0),
2546  acBufferLevel (0),
2547  acOptionFlags (0),
2548  acAudioSystem (NTV2_AUDIOSYSTEM_INVALID)
2549 {
2550  NTV2_ASSERT_STRUCT_VALID;
2551 }
2552 
2553 
2554 bool AUTOCIRCULATE_STATUS::CopyTo (AUTOCIRCULATE_STATUS_STRUCT & outOldStruct)
2555 {
2556  NTV2_ASSERT_STRUCT_VALID;
2557  outOldStruct.channelSpec = acCrosspoint;
2558  outOldStruct.state = acState;
2559  outOldStruct.startFrame = acStartFrame;
2560  outOldStruct.endFrame = acEndFrame;
2561  outOldStruct.activeFrame = acActiveFrame;
2562  outOldStruct.rdtscStartTime = acRDTSCStartTime;
2563  outOldStruct.audioClockStartTime = acAudioClockStartTime;
2564  outOldStruct.rdtscCurrentTime = acRDTSCCurrentTime;
2565  outOldStruct.audioClockCurrentTime = acAudioClockCurrentTime;
2566  outOldStruct.framesProcessed = acFramesProcessed;
2567  outOldStruct.framesDropped = acFramesDropped;
2568  outOldStruct.bufferLevel = acBufferLevel;
2569  outOldStruct.bWithAudio = NTV2_IS_VALID_AUDIO_SYSTEM (acAudioSystem);
2570  outOldStruct.bWithRP188 = acOptionFlags & AUTOCIRCULATE_WITH_RP188 ? 1 : 0;
2571  outOldStruct.bFbfChange = acOptionFlags & AUTOCIRCULATE_WITH_FBFCHANGE ? 1 : 0;
2572  outOldStruct.bFboChange = acOptionFlags & AUTOCIRCULATE_WITH_FBOCHANGE ? 1 : 0;
2573  outOldStruct.bWithColorCorrection = acOptionFlags & AUTOCIRCULATE_WITH_COLORCORRECT ? 1 : 0;
2574  outOldStruct.bWithVidProc = acOptionFlags & AUTOCIRCULATE_WITH_VIDPROC ? 1 : 0;
2575  outOldStruct.bWithCustomAncData = acOptionFlags & AUTOCIRCULATE_WITH_ANC ? 1 : 0;
2576  return true;
2577 }
2578 
2579 
2580 bool AUTOCIRCULATE_STATUS::CopyFrom (const AUTOCIRCULATE_STATUS_STRUCT & inOldStruct)
2581 {
2582  NTV2_ASSERT_STRUCT_VALID;
2583  acCrosspoint = inOldStruct.channelSpec;
2584  acState = inOldStruct.state;
2585  acStartFrame = inOldStruct.startFrame;
2586  acEndFrame = inOldStruct.endFrame;
2587  acActiveFrame = inOldStruct.activeFrame;
2588  acRDTSCStartTime = inOldStruct.rdtscStartTime;
2589  acAudioClockStartTime = inOldStruct.audioClockStartTime;
2590  acRDTSCCurrentTime = inOldStruct.rdtscCurrentTime;
2591  acAudioClockCurrentTime = inOldStruct.audioClockCurrentTime;
2592  acFramesProcessed = inOldStruct.framesProcessed;
2593  acFramesDropped = inOldStruct.framesDropped;
2594  acBufferLevel = inOldStruct.bufferLevel;
2595  acAudioSystem = NTV2_AUDIOSYSTEM_INVALID; // NTV2_AUDIOSYSTEM_1;
2596  acOptionFlags = (inOldStruct.bWithRP188 ? AUTOCIRCULATE_WITH_RP188 : 0) |
2597  (inOldStruct.bFbfChange ? AUTOCIRCULATE_WITH_FBFCHANGE : 0) |
2598  (inOldStruct.bFboChange ? AUTOCIRCULATE_WITH_FBOCHANGE : 0) |
2599  (inOldStruct.bWithColorCorrection ? AUTOCIRCULATE_WITH_COLORCORRECT : 0) |
2600  (inOldStruct.bWithVidProc ? AUTOCIRCULATE_WITH_VIDPROC : 0) |
2601  (inOldStruct.bWithCustomAncData ? AUTOCIRCULATE_WITH_ANC : 0);
2602  return true;
2603 }
2604 
2605 
2606 void AUTOCIRCULATE_STATUS::Clear (void)
2607 {
2608  NTV2_ASSERT_STRUCT_VALID;
2609  acCrosspoint = NTV2CROSSPOINT_INVALID;
2610  acState = NTV2_AUTOCIRCULATE_DISABLED;
2611  acStartFrame = 0;
2612  acEndFrame = 0;
2613  acActiveFrame = 0;
2614  acRDTSCStartTime = 0;
2615  acAudioClockStartTime = 0;
2616  acRDTSCCurrentTime = 0;
2617  acAudioClockCurrentTime = 0;
2618  acFramesProcessed = 0;
2619  acFramesDropped = 0;
2620  acBufferLevel = 0;
2621  acOptionFlags = 0;
2622  acAudioSystem = NTV2_AUDIOSYSTEM_INVALID;
2623 }
2624 
2625 
2626 NTV2Channel AUTOCIRCULATE_STATUS::GetChannel (void) const
2627 {
2628  return ::NTV2CrosspointToNTV2Channel(acCrosspoint);
2629 }
2630 
2631 
2632 struct ThousandsSeparator : std::numpunct <char>
2633 {
2634  virtual inline char do_thousands_sep() const {return ',';}
2635  virtual inline std::string do_grouping() const {return "\03";}
2636 };
2637 
2638 
2639 template <class T> string CommaStr (const T & inNum)
2640 {
2641  ostringstream oss;
2642  const locale loc (oss.getloc(), new ThousandsSeparator);
2643  oss.imbue (loc);
2644  oss << inNum;
2645  return oss.str();
2646 } // CommaStr
2647 
2648 
2649 string AUTOCIRCULATE_STATUS::operator [] (const unsigned inIndexNum) const
2650 {
2651  ostringstream oss;
2652  if (inIndexNum == 0)
2653  oss << ::NTV2AutoCirculateStateToString(acState);
2654  else if (!IsStopped())
2655  switch (inIndexNum)
2656  {
2657  case 1: oss << DEC(GetStartFrame()); break;
2658  case 2: oss << DEC(GetEndFrame()); break;
2659  case 3: oss << DEC(GetFrameCount()); break;
2660  case 4: oss << DEC(GetActiveFrame()); break;
2661  case 5: oss << xHEX0N(acRDTSCStartTime,16); break;
2662  case 6: oss << xHEX0N(acAudioClockStartTime,16); break;
2663  case 7: oss << DEC(acRDTSCCurrentTime); break;
2664  case 8: oss << DEC(acAudioClockCurrentTime); break;
2665  case 9: oss << CommaStr(GetProcessedFrameCount()); break;
2666  case 10: oss << CommaStr(GetDroppedFrameCount()); break;
2667  case 11: oss << DEC(GetBufferLevel()); break;
2668  case 12: oss << ::NTV2AudioSystemToString(acAudioSystem, true); break;
2669  case 13: oss << (WithRP188() ? "Yes" : "No"); break;
2670  case 14: oss << (WithLTC() ? "Yes" : "No"); break;
2671  case 15: oss << (WithFBFChange() ? "Yes" : "No"); break;
2672  case 16: oss << (WithFBOChange() ? "Yes" : "No"); break;
2673  case 17: oss << (WithColorCorrect() ? "Yes" : "No"); break;
2674  case 18: oss << (WithVidProc() ? "Yes" : "No"); break;
2675  case 19: oss << (WithCustomAnc() ? "Yes" : "No"); break;
2676  case 20: oss << (WithHDMIAuxData() ? "Yes" : "No"); break;
2677  case 21: oss << (IsFieldMode() ? "Yes" : "No"); break;
2678  default: break;
2679  }
2680  else if (inIndexNum < 22)
2681  oss << "---";
2682  return oss.str();
2683 }
2684 
2685 
2686 ostream & operator << (ostream & oss, const AUTOCIRCULATE_STATUS & inObj)
2687 {
2688  if (!inObj.IsStopped())
2689  oss << ::NTV2ChannelToString(inObj.GetChannel(), true) << ": "
2690  << (inObj.IsInput() ? "Input " : (inObj.IsOutput() ? "Output" : "*BAD* "))
2691  << setw(12) << ::NTV2AutoCirculateStateToString(inObj.acState) << " "
2692  << setw( 5) << inObj.GetStartFrame()
2693  << setw( 6) << inObj.GetEndFrame()
2694  << setw( 6) << inObj.GetActiveFrame()
2695  << setw( 8) << inObj.GetProcessedFrameCount()
2696  << setw( 8) << inObj.GetDroppedFrameCount()
2697  << setw( 7) << inObj.GetBufferLevel()
2698  << setw(10) << ::NTV2AudioSystemToString(inObj.acAudioSystem, true)
2699  << setw(10) << (inObj.WithRP188() ? "+RP188" : "-RP188")
2700  << setw(10) << (inObj.WithLTC() ? "+LTC" : "-LTC")
2701  << setw(10) << (inObj.WithFBFChange() ? "+FBFchg" : "-FBFchg")
2702  << setw(10) << (inObj.WithFBOChange() ? "+FBOchg" : "-FBOchg")
2703  << setw(10) << (inObj.WithColorCorrect() ? "+ColCor" : "-ColCor")
2704  << setw(10) << (inObj.WithVidProc() ? "+VidProc" : "-VidProc")
2705  << setw(10) << (inObj.WithCustomAnc() ? "+AncData" : "-AncData")
2706  << setw(10) << (inObj.WithHDMIAuxData() ? "+HDMIAux" : "-HDMIAux")
2707  << setw(10) << (inObj.IsFieldMode() ? "+FldMode" : "-FldMode");
2708  return oss;
2709 }
2710 
2711 
2712 NTV2SegmentedDMAInfo::NTV2SegmentedDMAInfo ()
2713 {
2714  Reset ();
2715 }
2716 
2717 
2718 NTV2SegmentedDMAInfo::NTV2SegmentedDMAInfo (const ULWord inNumSegments, const ULWord inNumActiveBytesPerRow, const ULWord inHostBytesPerRow, const ULWord inDeviceBytesPerRow)
2719 {
2720  Set (inNumSegments, inNumActiveBytesPerRow, inHostBytesPerRow, inDeviceBytesPerRow);
2721 }
2722 
2723 
2724 void NTV2SegmentedDMAInfo::Set (const ULWord inNumSegments, const ULWord inNumActiveBytesPerRow, const ULWord inHostBytesPerRow, const ULWord inDeviceBytesPerRow)
2725 {
2726  acNumSegments = inNumSegments;
2727  if (acNumSegments > 1)
2728  {
2729  acNumActiveBytesPerRow = inNumActiveBytesPerRow;
2730  acSegmentHostPitch = inHostBytesPerRow;
2731  acSegmentDevicePitch = inDeviceBytesPerRow;
2732  }
2733  else
2734  Reset ();
2735 }
2736 
2737 
2738 void NTV2SegmentedDMAInfo::Reset (void)
2739 {
2740  acNumSegments = acNumActiveBytesPerRow = acSegmentHostPitch = acSegmentDevicePitch = 0;
2741 }
2742 
2743 
2744 NTV2ColorCorrectionData::NTV2ColorCorrectionData ()
2745  : ccMode (NTV2_CCMODE_INVALID),
2746  ccSaturationValue (0)
2747 {
2748 }
2749 
2750 
2751 NTV2ColorCorrectionData::~NTV2ColorCorrectionData ()
2752 {
2753  Clear ();
2754 }
2755 
2756 
2757 void NTV2ColorCorrectionData::Clear (void)
2758 {
2759  ccMode = NTV2_CCMODE_INVALID;
2760  ccSaturationValue = 0;
2761  ccLookupTables.Deallocate();
2762 }
2763 
2764 
2765 bool NTV2ColorCorrectionData::Set (const NTV2ColorCorrectionMode inMode, const ULWord inSaturation, const void * pInTableData)
2766 {
2767  Clear();
2768  if (!NTV2_IS_VALID_COLOR_CORRECTION_MODE (inMode))
2769  return false;
2770 
2771  if (pInTableData)
2772  if (!ccLookupTables.CopyFrom(pInTableData, ULWord(NTV2_COLORCORRECTOR_TABLESIZE)))
2773  return false;
2774  ccMode = inMode;
2775  ccSaturationValue = (inMode == NTV2_CCMODE_3WAY) ? inSaturation : 0;
2776  return true;
2777 }
2778 
2779 
2780 AUTOCIRCULATE_TRANSFER::AUTOCIRCULATE_TRANSFER ()
2781  : acHeader (NTV2_TYPE_ACXFER, sizeof(AUTOCIRCULATE_TRANSFER)),
2782  acOutputTimeCodes (NTV2_MAX_NUM_TIMECODE_INDEXES * sizeof (NTV2_RP188)),
2783  acTransferStatus (),
2784  acInUserCookie (0),
2785  acInVideoDMAOffset (0),
2786  acInSegmentedDMAInfo (),
2787  acColorCorrection (),
2788  acFrameBufferFormat (NTV2_FBF_10BIT_YCBCR),
2789  acFrameBufferOrientation (NTV2_FRAMEBUFFER_ORIENTATION_TOPDOWN),
2790  acVidProcInfo (),
2791  acVideoQuarterSizeExpand (NTV2_QuarterSizeExpandOff),
2792  acPeerToPeerFlags (0),
2793  acFrameRepeatCount (1),
2794  acDesiredFrame (-1),
2795  acRP188 (),
2796  acCrosspoint (NTV2CROSSPOINT_INVALID)
2797 {
2798  if (acOutputTimeCodes.GetHostPointer ())
2799  ::memset (acOutputTimeCodes.GetHostPointer (), 0xFF, acOutputTimeCodes.GetByteCount ());
2800  NTV2_ASSERT_STRUCT_VALID;
2801 }
2802 
2803 
2804 AUTOCIRCULATE_TRANSFER::AUTOCIRCULATE_TRANSFER (ULWord * pInVideoBuffer, const ULWord inVideoByteCount, ULWord * pInAudioBuffer,
2805  const ULWord inAudioByteCount, ULWord * pInANCBuffer, const ULWord inANCByteCount,
2806  ULWord * pInANCF2Buffer, const ULWord inANCF2ByteCount)
2807  : acHeader (NTV2_TYPE_ACXFER, sizeof(AUTOCIRCULATE_TRANSFER)),
2808  acVideoBuffer (pInVideoBuffer, inVideoByteCount),
2809  acAudioBuffer (pInAudioBuffer, inAudioByteCount),
2810  acANCBuffer (pInANCBuffer, inANCByteCount),
2811  acANCField2Buffer (pInANCF2Buffer, inANCF2ByteCount),
2812  acOutputTimeCodes (NTV2_MAX_NUM_TIMECODE_INDEXES * sizeof (NTV2_RP188)),
2813  acTransferStatus (),
2814  acInUserCookie (0),
2815  acInVideoDMAOffset (0),
2816  acInSegmentedDMAInfo (),
2817  acColorCorrection (),
2818  acFrameBufferFormat (NTV2_FBF_10BIT_YCBCR),
2819  acFrameBufferOrientation (NTV2_FRAMEBUFFER_ORIENTATION_TOPDOWN),
2820  acVidProcInfo (),
2821  acVideoQuarterSizeExpand (NTV2_QuarterSizeExpandOff),
2822  acPeerToPeerFlags (0),
2823  acFrameRepeatCount (1),
2824  acDesiredFrame (-1),
2825  acRP188 (),
2826  acCrosspoint (NTV2CROSSPOINT_INVALID)
2827 {
2828  if (acOutputTimeCodes.GetHostPointer ())
2829  ::memset (acOutputTimeCodes.GetHostPointer (), 0xFF, acOutputTimeCodes.GetByteCount ());
2830  NTV2_ASSERT_STRUCT_VALID;
2831 }
2832 
2833 
2834 AUTOCIRCULATE_TRANSFER::~AUTOCIRCULATE_TRANSFER ()
2835 {
2836 }
2837 
2838 
2839 bool AUTOCIRCULATE_TRANSFER::SetBuffers (ULWord * pInVideoBuffer, const ULWord inVideoByteCount,
2840  ULWord * pInAudioBuffer, const ULWord inAudioByteCount,
2841  ULWord * pInANCBuffer, const ULWord inANCByteCount,
2842  ULWord * pInANCF2Buffer, const ULWord inANCF2ByteCount)
2843 {
2844  NTV2_ASSERT_STRUCT_VALID;
2845  return SetVideoBuffer (pInVideoBuffer, inVideoByteCount)
2846  && SetAudioBuffer (pInAudioBuffer, inAudioByteCount)
2847  && SetAncBuffers (pInANCBuffer, inANCByteCount, pInANCF2Buffer, inANCF2ByteCount);
2848 }
2849 
2850 
2851 bool AUTOCIRCULATE_TRANSFER::SetVideoBuffer (ULWord * pInVideoBuffer, const ULWord inVideoByteCount)
2852 {
2853  NTV2_ASSERT_STRUCT_VALID;
2854  acVideoBuffer.Set (pInVideoBuffer, inVideoByteCount);
2855  return true;
2856 }
2857 
2858 
2859 bool AUTOCIRCULATE_TRANSFER::SetAudioBuffer (ULWord * pInAudioBuffer, const ULWord inAudioByteCount)
2860 {
2861  NTV2_ASSERT_STRUCT_VALID;
2862  acAudioBuffer.Set (pInAudioBuffer, inAudioByteCount);
2863  return true;
2864 }
2865 
2866 
2867 bool AUTOCIRCULATE_TRANSFER::SetAncBuffers (ULWord * pInANCBuffer, const ULWord inANCByteCount, ULWord * pInANCF2Buffer, const ULWord inANCF2ByteCount)
2868 {
2869  NTV2_ASSERT_STRUCT_VALID;
2870  acANCBuffer.Set (pInANCBuffer, inANCByteCount);
2871  acANCField2Buffer.Set (pInANCF2Buffer, inANCF2ByteCount);
2872  return true;
2873 }
2874 
2875 static const NTV2_RP188 INVALID_TIMECODE_VALUE;
2876 
2877 
2878 bool AUTOCIRCULATE_TRANSFER::SetOutputTimeCodes (const NTV2TimeCodes & inValues)
2879 {
2880  NTV2_ASSERT_STRUCT_VALID;
2881  ULWord maxNumValues (acOutputTimeCodes.GetByteCount() / sizeof(NTV2_RP188));
2882  NTV2_RP188 * pArray (reinterpret_cast<NTV2_RP188*>(acOutputTimeCodes.GetHostPointer()));
2883  if (!pArray)
2884  return false;
2885  if (maxNumValues > NTV2_MAX_NUM_TIMECODE_INDEXES)
2886  maxNumValues = NTV2_MAX_NUM_TIMECODE_INDEXES;
2887 
2888  for (UWord ndx (0); ndx < UWord(maxNumValues); ndx++)
2889  {
2890  const NTV2TCIndex tcIndex (static_cast<NTV2TCIndex>(ndx));
2891  NTV2TimeCodesConstIter iter (inValues.find(tcIndex));
2892  pArray[ndx] = (iter != inValues.end()) ? iter->second : INVALID_TIMECODE_VALUE;
2893  } // for each possible NTV2TCSource value
2894  return true;
2895 }
2896 
2897 
2898 bool AUTOCIRCULATE_TRANSFER::SetOutputTimeCode (const NTV2_RP188 & inTimeCode, const NTV2TCIndex inTCIndex)
2899 {
2900  NTV2_ASSERT_STRUCT_VALID;
2901  ULWord maxNumValues (acOutputTimeCodes.GetByteCount() / sizeof(NTV2_RP188));
2902  NTV2_RP188 * pArray (reinterpret_cast<NTV2_RP188*>(acOutputTimeCodes.GetHostPointer()));
2903  if (!pArray)
2904  return false;
2905  if (maxNumValues > NTV2_MAX_NUM_TIMECODE_INDEXES)
2906  maxNumValues = NTV2_MAX_NUM_TIMECODE_INDEXES;
2907  if (!NTV2_IS_VALID_TIMECODE_INDEX(inTCIndex))
2908  return false;
2909 
2910  pArray[inTCIndex] = inTimeCode;
2911  return true;
2912 }
2913 
2914 bool AUTOCIRCULATE_TRANSFER::SetAllOutputTimeCodes (const NTV2_RP188 & inTimeCode, const bool inIncludeF2)
2915 {
2916  NTV2_ASSERT_STRUCT_VALID;
2917  ULWord maxNumValues (acOutputTimeCodes.GetByteCount() / sizeof(NTV2_RP188));
2918  NTV2_RP188 * pArray (reinterpret_cast<NTV2_RP188*>(acOutputTimeCodes.GetHostPointer()));
2919  if (!pArray)
2920  return false;
2921  if (maxNumValues > NTV2_MAX_NUM_TIMECODE_INDEXES)
2922  maxNumValues = NTV2_MAX_NUM_TIMECODE_INDEXES;
2923 
2924  for (ULWord tcIndex(0); tcIndex < maxNumValues; tcIndex++)
2925  if (NTV2_IS_ATC_VITC2_TIMECODE_INDEX(tcIndex))
2926  pArray[tcIndex] = inIncludeF2 ? inTimeCode : INVALID_TIMECODE_VALUE;
2927  else
2928  pArray[tcIndex] = inTimeCode;
2929  return true;
2930 }
2931 
2932 
2933 bool AUTOCIRCULATE_TRANSFER::SetFrameBufferFormat (const NTV2FrameBufferFormat inNewFormat)
2934 {
2935  NTV2_ASSERT_STRUCT_VALID;
2936  if (!NTV2_IS_VALID_FRAME_BUFFER_FORMAT (inNewFormat))
2937  return false;
2938  acFrameBufferFormat = inNewFormat;
2939  return true;
2940 }
2941 
2942 
2943 void AUTOCIRCULATE_TRANSFER::Clear (void)
2944 {
2945  NTV2_ASSERT_STRUCT_VALID;
2946  SetBuffers (AJA_NULL, 0, AJA_NULL, 0, AJA_NULL, 0, AJA_NULL, 0);
2947 }
2948 
2949 
2950 bool AUTOCIRCULATE_TRANSFER::EnableSegmentedDMAs (const ULWord inNumSegments, const ULWord inNumActiveBytesPerRow,
2951  const ULWord inHostBytesPerRow, const ULWord inDeviceBytesPerRow)
2952 {
2953  NTV2_ASSERT_STRUCT_VALID;
2954  // Cannot allow segmented DMAs if video buffer was self-allocated by the SDK, since the video buffer size holds the segment size (in bytes)...
2955  if (acVideoBuffer.IsAllocatedBySDK ())
2956  return false; // Disallow
2957  acInSegmentedDMAInfo.Set (inNumSegments, inNumActiveBytesPerRow, inHostBytesPerRow, inDeviceBytesPerRow);
2958  return true;
2959 }
2960 
2961 
2962 bool AUTOCIRCULATE_TRANSFER::DisableSegmentedDMAs (void)
2963 {
2964  NTV2_ASSERT_STRUCT_VALID;
2965  acInSegmentedDMAInfo.Reset ();
2966  return true;
2967 }
2968 
2969 
2970 bool AUTOCIRCULATE_TRANSFER::SegmentedDMAsEnabled (void) const
2971 {
2972  NTV2_ASSERT_STRUCT_VALID;
2973  return acInSegmentedDMAInfo.acNumSegments > 1;
2974 }
2975 
2976 
2977 bool AUTOCIRCULATE_TRANSFER::GetInputTimeCodes (NTV2TimeCodeList & outValues) const
2978 {
2979  NTV2_ASSERT_STRUCT_VALID;
2980  return acTransferStatus.acFrameStamp.GetInputTimeCodes (outValues);
2981 }
2982 
2983 
2984 bool AUTOCIRCULATE_TRANSFER::GetInputTimeCode (NTV2_RP188 & outTimeCode, const NTV2TCIndex inTCIndex) const
2985 {
2986  NTV2_ASSERT_STRUCT_VALID;
2987  return acTransferStatus.acFrameStamp.GetInputTimeCode (outTimeCode, inTCIndex);
2988 }
2989 
2990 
2991 bool AUTOCIRCULATE_TRANSFER::GetInputTimeCodes (NTV2TimeCodes & outTimeCodes, const NTV2Channel inSDIInput, const bool inValidOnly) const
2992 {
2993  NTV2_ASSERT_STRUCT_VALID;
2994  return acTransferStatus.acFrameStamp.GetInputTimeCodes (outTimeCodes, inSDIInput, inValidOnly);
2995 }
2996 
2997 
2998 NTV2DebugLogging::NTV2DebugLogging(const bool inEnable)
2999  : mHeader (NTV2_TYPE_AJADEBUGLOGGING, sizeof (NTV2DebugLogging)),
3000  mSharedMemory (inEnable ? AJADebug::GetPrivateDataLoc() : AJA_NULL, inEnable ? AJADebug::GetPrivateDataLen() : 0)
3001 {
3002 }
3003 
3004 
3005 ostream & NTV2DebugLogging::Print (ostream & inOutStream) const
3006 {
3007  NTV2_ASSERT_STRUCT_VALID;
3008  inOutStream << mHeader << " shMem=" << mSharedMemory << " " << mTrailer;
3009  return inOutStream;
3010 }
3011 
3012 
3013 
3014 NTV2BufferLock::NTV2BufferLock()
3015  : mHeader (NTV2_TYPE_AJABUFFERLOCK, sizeof(NTV2BufferLock))
3016 {
3017  NTV2_ASSERT_STRUCT_VALID;
3018  SetFlags(0);
3019  SetMaxLockSize(0);
3020 }
3021 
3022 NTV2BufferLock::NTV2BufferLock (const NTV2Buffer & inBuffer, const ULWord inFlags)
3023  : mHeader (NTV2_TYPE_AJABUFFERLOCK, sizeof(NTV2BufferLock))
3024 {
3025  NTV2_ASSERT_STRUCT_VALID;
3026  SetBuffer(inBuffer);
3027  SetFlags(inFlags);
3028  SetMaxLockSize(0);
3029 }
3030 
3031 NTV2BufferLock::NTV2BufferLock(const ULWord * pInBuffer, const ULWord inByteCount, const ULWord inFlags)
3032  : mHeader (NTV2_TYPE_AJABUFFERLOCK, sizeof(NTV2BufferLock))
3033 {
3034  NTV2_ASSERT_STRUCT_VALID;
3035  SetBuffer (NTV2Buffer(pInBuffer, inByteCount));
3036  SetFlags (inFlags);
3037  SetMaxLockSize(0);
3038 }
3039 
3040 NTV2BufferLock::NTV2BufferLock(const ULWord64 inMaxLockSize, const ULWord inFlags)
3041  : mHeader (NTV2_TYPE_AJABUFFERLOCK, sizeof(NTV2BufferLock))
3042 {
3043  NTV2_ASSERT_STRUCT_VALID;
3044  SetBuffer (NTV2Buffer());
3045  SetFlags (inFlags);
3046  SetMaxLockSize(inMaxLockSize);
3047 }
3048 
3049 bool NTV2BufferLock::SetBuffer (const NTV2Buffer & inBuffer)
3050 { // Just use address & length (don't deep copy)...
3051  NTV2_ASSERT_STRUCT_VALID;
3052  return mBuffer.Set (inBuffer.GetHostPointer(), inBuffer.GetByteCount());
3053 }
3054 
3055 ostream & NTV2BufferLock::Print (ostream & inOutStream) const
3056 {
3057  NTV2_ASSERT_STRUCT_VALID;
3058  inOutStream << mHeader << mBuffer << " flags=" << xHEX0N(mFlags,8) << " " << mTrailer;
3059  return inOutStream;
3060 }
3061 
3062 
3063 NTV2Bitstream::NTV2Bitstream()
3064  : mHeader (NTV2_TYPE_AJABITSTREAM, sizeof(NTV2Bitstream))
3065 {
3066  NTV2_ASSERT_STRUCT_VALID;
3067 }
3068 
3069 NTV2Bitstream::NTV2Bitstream (const NTV2Buffer & inBuffer, const ULWord inFlags)
3070  : mHeader (NTV2_TYPE_AJABITSTREAM, sizeof(NTV2Bitstream))
3071 {
3072  NTV2_ASSERT_STRUCT_VALID;
3073  SetBuffer(inBuffer);
3074  SetFlags(inFlags);
3075 }
3076 
3077 NTV2Bitstream::NTV2Bitstream(const ULWord * pInBuffer, const ULWord inByteCount, const ULWord inFlags)
3078  : mHeader (NTV2_TYPE_AJABITSTREAM, sizeof(NTV2Bitstream))
3079 {
3080  NTV2_ASSERT_STRUCT_VALID;
3081  SetBuffer (NTV2Buffer(pInBuffer, inByteCount));
3082  SetFlags (inFlags);
3083 }
3084 
3085 bool NTV2Bitstream::SetBuffer (const NTV2Buffer & inBuffer)
3086 { // Just use address & length (don't deep copy)...
3087  NTV2_ASSERT_STRUCT_VALID;
3088  return mBuffer.Set (inBuffer.GetHostPointer(), inBuffer.GetByteCount());
3089 }
3090 
3091 ostream & NTV2Bitstream::Print (ostream & inOutStream) const
3092 {
3093  NTV2_ASSERT_STRUCT_VALID;
3094  inOutStream << mHeader << mBuffer << " flags=" << xHEX0N(mFlags,8) << " " << mTrailer;
3095  return inOutStream;
3096 }
3097 
3098 NTV2StreamChannel::NTV2StreamChannel()
3099  : mHeader (NTV2_TYPE_AJASTREAMCHANNEL, sizeof(NTV2StreamChannel))
3100 {
3101  NTV2_ASSERT_STRUCT_VALID;
3102 }
3103 
3104 ostream & NTV2StreamChannel::Print (ostream & inOutStream) const
3105 {
3106  NTV2_ASSERT_STRUCT_VALID;
3107  inOutStream << mHeader << mChannel << " flags=" << xHEX0N(mFlags,8) << xHEX0N(mStatus, 8) << " " << mTrailer;
3108  return inOutStream;
3109 }
3110 
3111 NTV2StreamBuffer::NTV2StreamBuffer()
3112  : mHeader (NTV2_TYPE_AJASTREAMBUFFER, sizeof(NTV2StreamBuffer))
3113 {
3114  NTV2_ASSERT_STRUCT_VALID;
3115 }
3116 
3117 ostream & NTV2StreamBuffer::Print (ostream & inOutStream) const
3118 {
3119  NTV2_ASSERT_STRUCT_VALID;
3120  inOutStream << mHeader << mChannel << " flags=" << xHEX0N(mFlags,8) << xHEX0N(mStatus, 8) << " " << mTrailer;
3121  return inOutStream;
3122 }
3123 
3124 NTV2GetRegisters::NTV2GetRegisters (const NTV2RegNumSet & inRegisterNumbers)
3125  : mHeader (NTV2_TYPE_GETREGS, sizeof(NTV2GetRegisters)),
3126  mInNumRegisters (ULWord (inRegisterNumbers.size ())),
3127  mOutNumRegisters (0)
3128 {
3129  NTV2_ASSERT_STRUCT_VALID;
3130  ResetUsing (inRegisterNumbers);
3131 }
3132 
3133 
3134 NTV2GetRegisters::NTV2GetRegisters (NTV2RegisterReads & inRegReads)
3135  : mHeader (NTV2_TYPE_GETREGS, sizeof(NTV2GetRegisters)),
3136  mInNumRegisters (ULWord (inRegReads.size ())),
3137  mOutNumRegisters (0)
3138 {
3139  NTV2_ASSERT_STRUCT_VALID;
3140  ResetUsing (inRegReads);
3141 }
3142 
3143 
3144 bool NTV2GetRegisters::ResetUsing (const NTV2RegNumSet & inRegisterNumbers)
3145 {
3146  NTV2_ASSERT_STRUCT_VALID;
3147  mInNumRegisters = ULWord(inRegisterNumbers.size());
3148  mOutNumRegisters = 0;
3149  bool result ( mInRegisters.Allocate(mInNumRegisters * sizeof(ULWord))
3150  && mOutGoodRegisters.Allocate(mInNumRegisters * sizeof(ULWord))
3151  && mOutValues.Allocate(mInNumRegisters * sizeof(ULWord)));
3152  if (!result)
3153  return false;
3154  mInRegisters.Fill(ULWord(0)); mOutGoodRegisters.Fill(ULWord(0)); mOutValues.Fill(ULWord(0));
3155 
3156  ULWord * pRegArray(mInRegisters);
3157  if (!pRegArray)
3158  return false;
3159 
3160  ULWord ndx(0);
3161  for (NTV2RegNumSetConstIter iter(inRegisterNumbers.begin()); iter != inRegisterNumbers.end(); ++iter)
3162  pRegArray[ndx++] = *iter;
3163  return (ndx * sizeof(ULWord)) == mInRegisters.GetByteCount();
3164 }
3165 
3166 bool NTV2GetRegisters::GetRequestedRegisterNumbers (NTV2RegNumSet & outRegNums) const
3167 {
3168  outRegNums.clear();
3169  if (!mInNumRegisters)
3170  return true; // None requested
3171  if (!mInRegisters)
3172  return false; // Empty/NULL reg num buffer
3173  if (mInRegisters.GetByteCount()/4 < mInNumRegisters)
3174  return false; // Sanity check failed: Reg num buffer too small
3175 
3176  const ULWord * pRegNums(mInRegisters);
3177  for (ULWord ndx(0); ndx < mInNumRegisters; ndx++)
3178  if (outRegNums.find(pRegNums[ndx]) == outRegNums.end())
3179  outRegNums.insert(pRegNums[ndx]);
3180  return true;
3181 }
3182 
3183 
3184 bool NTV2GetRegisters::GetGoodRegisters (NTV2RegNumSet & outGoodRegNums) const
3185 {
3186  NTV2_ASSERT_STRUCT_VALID;
3187  outGoodRegNums.clear();
3188  if (!mOutGoodRegisters)
3189  return false; // Empty/NULL 'mOutGoodRegisters' array!
3190  if (!mOutNumRegisters)
3191  return false; // The driver says zero successfully read!
3192  if (mOutNumRegisters > mInNumRegisters)
3193  return false; // Sanity check failed: mOutNumRegisters must be less than or equal to mInNumRegisters!
3194 
3195  const ULWord * pRegArray (mOutGoodRegisters);
3196  for (ULWord ndx(0); ndx < mOutNumRegisters; ndx++)
3197  outGoodRegNums.insert(pRegArray[ndx]);
3198  return true;
3199 }
3200 
3201 bool NTV2GetRegisters::GetBadRegisters (NTV2RegNumSet & outBadRegNums) const
3202 {
3203  NTV2_ASSERT_STRUCT_VALID;
3204  outBadRegNums.clear();
3205  NTV2RegNumSet reqRegNums, goodRegNums;
3206  if (!GetRequestedRegisterNumbers(reqRegNums))
3207  return false;
3208  if (!GetGoodRegisters(goodRegNums))
3209  return false;
3210  if (reqRegNums == goodRegNums)
3211  return true; // Requested reg nums identical to those that were read successfully
3212 
3213  // Subtract goodRegNums from reqRegNums...
3214  std::set_difference (reqRegNums.begin(), reqRegNums.end(),
3215  goodRegNums.begin(), goodRegNums.end(),
3216  std::inserter(outBadRegNums, outBadRegNums.begin()));
3217  return true;
3218 }
3219 
3220 bool NTV2GetRegisters::PatchRegister (const ULWord inRegNum, const ULWord inValue)
3221 {
3222  if (!mOutGoodRegisters)
3223  return false; // Empty/null 'mOutGoodRegisters' array!
3224  if (!mOutNumRegisters)
3225  return false; // Driver says zero successfully read!
3226  if (mOutNumRegisters > mInNumRegisters)
3227  return false; // Sanity check failed: mOutNumRegisters must be less than or equal to mInNumRegisters!
3228  if (!mOutValues)
3229  return false; // Empty/null 'mOutValues' array!
3230  if (mOutGoodRegisters.GetByteCount() != mOutValues.GetByteCount())
3231  return false; // Sanity check failed: These sizes should match
3232  const ULWord * pRegArray (mOutGoodRegisters);
3233  ULWord * pValArray (mOutValues);
3234  for (ULWord ndx(0); ndx < mOutNumRegisters; ndx++)
3235  if (pRegArray[ndx] == inRegNum)
3236  {
3237  pValArray[ndx] = inValue;
3238  return true;
3239  }
3240  return false; // Not found
3241 }
3242 
3243 
3244 bool NTV2GetRegisters::GetRegisterValues (NTV2RegisterValueMap & outValues) const
3245 {
3246  NTV2_ASSERT_STRUCT_VALID;
3247  outValues.clear ();
3248  if (!mOutGoodRegisters)
3249  return false; // Empty/null 'mOutGoodRegisters' array!
3250  if (!mOutNumRegisters)
3251  return false; // Driver says zero successfully read!
3252  if (mOutNumRegisters > mInNumRegisters)
3253  return false; // Sanity check failed: mOutNumRegisters must be less than or equal to mInNumRegisters!
3254  if (!mOutValues)
3255  return false; // Empty/null 'mOutValues' array!
3256  if (mOutGoodRegisters.GetByteCount() != mOutValues.GetByteCount())
3257  return false; // Sanity check failed: These sizes should match
3258 
3259  const ULWord * pRegArray (mOutGoodRegisters);
3260  const ULWord * pValArray (mOutValues);
3261  for (ULWord ndx(0); ndx < mOutNumRegisters; ndx++)
3262  {
3263  outValues [pRegArray[ndx]] = pValArray[ndx];
3264 #if 0 // Fake KONAIP25G from C4412G (see also CNTV2XXXXDriverInterface::ReadRegister):
3265  if (pRegArray[ndx] == kRegBoardID && pValArray[ndx] == DEVICE_ID_CORVID44_8K)
3266  outValues [pRegArray[ndx]] = DEVICE_ID_KONAIP_25G;
3267  else if (pRegArray[ndx] == kRegReserved83 || pRegArray[ndx] == kRegLPRJ45IP)
3268  outValues [pRegArray[ndx]] = 0x0A03FAD9; // Local IPv4 10.3.250.217
3269 #endif // 0
3270  }
3271  return true;
3272 }
3273 
3274 
3275 bool NTV2GetRegisters::GetRegisterValues (NTV2RegisterReads & outValues) const
3276 {
3277  NTV2RegisterValueMap regValMap;
3278  if (!GetRegisterValues(regValMap))
3279  return false;
3280 
3281  if (outValues.empty())
3282  {
3283  for (NTV2RegValueMapConstIter it(regValMap.begin()); it != regValMap.end(); ++it)
3284  {
3285  NTV2RegInfo regInfo(/*regNum*/it->first, /*regVal*/it->second);
3286 #if 0 // Fake KONAIP25G from C4412G (see also CNTV2XXXXDriverInterface::ReadRegister):
3287  if (regInfo.regNum() == kRegBoardID && regInfo.value() == DEVICE_ID_CORVID44_8K)
3288  regInfo.setValue(DEVICE_ID_KONAIP_25G);
3289  else if (regInfo.regNum() == kRegReserved83 || regInfo.regNum() == kRegLPRJ45IP)
3290  regInfo.setValue(0x0A03FAD9); // Local IPv4 10.3.250.217
3291 #endif // 0
3292  outValues.push_back(regInfo);
3293  }
3294  return true;
3295  }
3296  else
3297  {
3298  uint32_t missingTally(0);
3299  for (NTV2RegisterReadsIter it (outValues.begin()); it != outValues.end(); ++it)
3300  {
3301  NTV2RegValueMapConstIter mapIter(regValMap.find(it->registerNumber));
3302  if (mapIter == regValMap.end())
3303  missingTally++; // Missing register
3304  it->registerValue = mapIter->second;
3305 #if 0 // Fake KONAIP25G from C4412G (see also CNTV2XXXXDriverInterface::ReadRegister):
3306  if (it->registerNumber == kRegBoardID && it->registerValue == DEVICE_ID_CORVID44_8K)
3307  it->registerValue = DEVICE_ID_KONAIP_25G;
3308  else if (it->registerNumber == kRegReserved83 || it->registerNumber == kRegLPRJ45IP)
3309  it->registerValue = 0x0A03FAD9; // Local IPv4 10.3.250.217
3310 #endif // 0
3311  }
3312  return !missingTally;
3313  }
3314 }
3315 
3316 
3317 ostream & NTV2GetRegisters::Print (ostream & inOutStream) const
3318 {
3319  inOutStream << mHeader << ", numRegs=" << mInNumRegisters << ", inRegs=" << mInRegisters << ", outNumGoodRegs=" << mOutNumRegisters
3320  << ", outGoodRegs=" << mOutGoodRegisters << ", outValues=" << mOutValues << ", " << mTrailer;
3321  return inOutStream;
3322 }
3323 
3324 
3325 NTV2SetRegisters::NTV2SetRegisters (const NTV2RegisterWrites & inRegWrites)
3326  : mHeader (NTV2_TYPE_SETREGS, sizeof(NTV2SetRegisters)),
3327  mInNumRegisters (ULWord(inRegWrites.size())),
3328  mOutNumFailures (0)
3329 {
3330  ResetUsing(inRegWrites);
3331 }
3332 
3333 
3334 bool NTV2SetRegisters::ResetUsing (const NTV2RegisterWrites & inRegWrites)
3335 {
3336  NTV2_ASSERT_STRUCT_VALID;
3337  mInNumRegisters = ULWord(inRegWrites.size());
3338  mOutNumFailures = 0;
3339  const bool result (mInRegInfos.Allocate (mInNumRegisters * sizeof(NTV2RegInfo))
3340  && mOutBadRegIndexes.Allocate (mInNumRegisters * sizeof(UWord)));
3341  if (!result)
3342  return false;
3343 
3344  ULWord ndx (0);
3345  NTV2RegInfo * pRegInfoArray (mInRegInfos);
3346  UWord * pBadRegIndexes (mOutBadRegIndexes);
3347 
3348  for (NTV2RegisterWritesConstIter it(inRegWrites.begin()); it != inRegWrites.end(); ++it)
3349  {
3350  if (pBadRegIndexes)
3351  pBadRegIndexes[ndx] = 0;
3352  if (pRegInfoArray)
3353  pRegInfoArray[ndx++] = *it;
3354  }
3355  NTV2_ASSERT((ndx * sizeof(NTV2RegInfo)) == mInRegInfos.GetByteCount());
3356  NTV2_ASSERT((ndx * sizeof(UWord)) == mOutBadRegIndexes.GetByteCount());
3357  return result;
3358 }
3359 
3360 
3361 bool NTV2SetRegisters::GetFailedRegisterWrites (NTV2RegisterWrites & outFailedRegWrites) const
3362 {
3363  NTV2_ASSERT_STRUCT_VALID;
3364  outFailedRegWrites.clear();
3365  return true;
3366 }
3367 
3368 bool NTV2SetRegisters::GetRequestedRegisterWrites (NTV2RegWrites & outRegWrites) const
3369 {
3370  outRegWrites.clear();
3371  if (!mInNumRegisters)
3372  return false;
3373  if (!mInRegInfos)
3374  return false;
3375 
3376  outRegWrites.reserve(size_t(mInNumRegisters));
3377  const NTV2RegInfo * pRegInfos(mInRegInfos);
3378  for (ULWord ndx(0); ndx < mInNumRegisters; ndx++)
3379  outRegWrites.push_back(pRegInfos[ndx]);
3380  return true;
3381 }
3382 
3383 ostream & NTV2SetRegisters::Print (ostream & oss) const
3384 {
3385  NTV2_ASSERT_STRUCT_VALID;
3386  oss << mHeader << ": numRegs=" << mInNumRegisters << " inRegInfos=" << mInRegInfos << " numFailures=" << DEC(mOutNumFailures)
3387  << " outBadRegIndexes=" << mOutBadRegIndexes << ": " << mTrailer;
3388  const UWord * pBadRegIndexes (mOutBadRegIndexes);
3389  const UWord maxNumBadRegIndexes (UWord(mOutBadRegIndexes.GetByteCount() / sizeof(UWord)));
3390  const NTV2RegInfo * pRegInfoArray (mInRegInfos);
3391  const UWord maxNumRegInfos (UWord(mInRegInfos.GetByteCount() / sizeof(NTV2RegInfo)));
3392  if (pBadRegIndexes && maxNumBadRegIndexes && pRegInfoArray && maxNumRegInfos && mOutNumFailures)
3393  {
3394  oss << endl;
3395  for (UWord num(0); num < maxNumBadRegIndexes; num++)
3396  {
3397  const UWord badRegIndex (pBadRegIndexes[num]);
3398  if (badRegIndex < maxNumRegInfos)
3399  {
3400  const NTV2RegInfo & badRegInfo (pRegInfoArray[badRegIndex]);
3401  oss << "Failure " << num << ": " << badRegInfo << endl;
3402  }
3403  }
3404  }
3405  return oss;
3406 }
3407 
3408 
3409 bool NTV2RegInfo::operator < (const NTV2RegInfo & inRHS) const
3410 {
3411  typedef std::pair <ULWord, ULWord> ULWordPair;
3412  typedef std::pair <ULWordPair, ULWordPair> ULWordPairs;
3413  const ULWordPairs rhs (ULWordPair (inRHS.registerNumber, inRHS.registerValue), ULWordPair (inRHS.registerMask, inRHS.registerShift));
3414  const ULWordPairs mine(ULWordPair (registerNumber, registerValue), ULWordPair (registerMask, registerShift));
3415  return mine < rhs;
3416 }
3417 
3418 ostream & NTV2RegInfo::Print (ostream & oss, const bool inAsCode) const
3419 {
3420  if (inAsCode)
3421  return PrintCode(oss);
3422  const string regName (CNTV2RegisterExpert::GetDisplayName(NTV2RegisterNumber(registerNumber)));
3423  oss << "[" << regName << "|" << DEC(registerNumber) << ": val=" << xHEX0N(registerValue,8);
3424  if (registerMask != 0xFFFFFFFF)
3425  oss << " msk=" << xHEX0N(registerMask,8);
3426  if (registerShift)
3427  oss << " shf=" << DEC(registerShift);
3428  return oss << "]";
3429 }
3430 
3431 ostream & NTV2RegInfo::PrintCode (ostream & oss, const int inRadix, const NTV2DeviceID inDeviceID) const
3432 {
3433  const string regName (CNTV2RegisterExpert::GetDisplayName(NTV2RegisterNumber(registerNumber)));
3434  const bool readOnly (CNTV2RegisterExpert::IsReadOnly(registerNumber));
3435  const bool badName (regName.find(' ') != string::npos);
3436  if (readOnly)
3437  oss << "//\t";
3438  oss << "theDevice.WriteRegister (";
3439  if (badName)
3440  oss << DEC(registerNumber);
3441  else
3442  oss << regName;
3443  switch (inRadix)
3444  {
3445  case 2: oss << ", " << BIN032(registerValue); break;
3446  case 8: oss << ", " << OCT(registerValue); break;
3447  case 10: oss << ", " << DEC(registerValue); break;
3448  default: oss << ", " << xHEX0N(registerValue,8); break;
3449  }
3450  if (registerMask != 0xFFFFFFFF)
3451  switch (inRadix)
3452  {
3453  case 2: oss << ", " << BIN032(registerMask); break;
3454  case 8: oss << ", " << OCT(registerMask); break;
3455  case 10: oss << ", " << DEC(registerMask); break;
3456  default: oss << ", " << xHEX0N(registerMask,8); break;
3457  }
3458  if (registerShift)
3459  oss << ", " << DEC(registerShift);
3460  oss << "); // ";
3461  if (badName)
3462  oss << regName;
3463  else
3464  oss << "Reg " << DEC(registerNumber);
3465  // Decode the reg value...
3466  string info(CNTV2RegisterExpert::GetDisplayValue(registerNumber, registerValue, inDeviceID));
3467  if (!info.empty()) // and add to end of comment
3468  oss << " // " << aja::replace(info, "\n", ", ");
3469  return oss;
3470 }
3471 
3472 
3473 ostream & NTV2PrintULWordVector (const NTV2ULWordVector & inObj, ostream & inOutStream)
3474 {
3475  for (NTV2ULWordVector::const_iterator it(inObj.begin()); it != inObj.end(); ++it)
3476  inOutStream << " " << HEX0N(*it,8);
3477  return inOutStream;
3478 }
3479 
3480 
3481 ostream & NTV2PrintChannelList (const NTV2ChannelList & inObj, const bool inCompact, ostream & inOutStream)
3482 {
3483  inOutStream << (inCompact ? "Ch[" : "[");
3484  for (NTV2ChannelListConstIter it(inObj.begin()); it != inObj.end(); )
3485  {
3486  if (inCompact)
3487  inOutStream << DEC(*it+1);
3488  else
3489  inOutStream << ::NTV2ChannelToString(*it);
3490  if (++it != inObj.end())
3491  inOutStream << (inCompact ? "|" : ",");
3492  }
3493  return inOutStream << "]";
3494 }
3495 
3496 string NTV2ChannelListToStr (const NTV2ChannelList & inObj, const bool inCompact)
3497 { ostringstream oss;
3498  ::NTV2PrintChannelList (inObj, inCompact, oss);
3499  return oss.str();
3500 }
3501 
3502 ostream & NTV2PrintChannelSet (const NTV2ChannelSet & inObj, const bool inCompact, ostream & inOutStream)
3503 {
3504  inOutStream << (inCompact ? "Ch{" : "{");
3505  for (NTV2ChannelSetConstIter it(inObj.begin()); it != inObj.end(); )
3506  {
3507  if (inCompact)
3508  inOutStream << DEC(*it+1);
3509  else
3510  inOutStream << ::NTV2ChannelToString(*it);
3511  if (++it != inObj.end())
3512  inOutStream << (inCompact ? "|" : ",");
3513  }
3514  return inOutStream << "}";
3515 }
3516 
3517 string NTV2ChannelSetToStr (const NTV2ChannelSet & inObj, const bool inCompact)
3518 { ostringstream oss;
3519  ::NTV2PrintChannelSet (inObj, inCompact, oss);
3520  return oss.str();
3521 }
3522 
3523 NTV2ChannelSet NTV2MakeChannelSet (const NTV2Channel inFirstChannel, const UWord inNumChannels)
3524 {
3525  NTV2ChannelSet result;
3526  for (NTV2Channel ch(inFirstChannel); ch < NTV2Channel(inFirstChannel+inNumChannels); ch = NTV2Channel(ch+1))
3527  if (NTV2_IS_VALID_CHANNEL(ch))
3528  result.insert(ch);
3529  return result;
3530 }
3531 
3532 NTV2ChannelSet NTV2MakeChannelSet (const NTV2ChannelList inChannels)
3533 {
3534  NTV2ChannelSet result;
3535  for (NTV2ChannelListConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
3536  result.insert(*it);
3537  return result;
3538 }
3539 
3540 NTV2ChannelList NTV2MakeChannelList (const NTV2Channel inFirstChannel, const UWord inNumChannels)
3541 {
3542  NTV2ChannelList result;
3543  for (NTV2Channel ch(inFirstChannel); ch < NTV2Channel(inFirstChannel+inNumChannels); ch = NTV2Channel(ch+1))
3544  if (NTV2_IS_VALID_CHANNEL(ch))
3545  result.push_back(ch);
3546  return result;
3547 }
3548 
3549 NTV2ChannelList NTV2MakeChannelList (const NTV2ChannelSet inChannels)
3550 {
3551  NTV2ChannelList result;
3552  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
3553  result.push_back(*it);
3554  return result;
3555 }
3556 
3557 ostream & NTV2PrintAudioSystemSet (const NTV2AudioSystemSet & inObj, const bool inCompact, std::ostream & inOutStream)
3558 {
3559  inOutStream << (inCompact ? "AudSys{" : "{");
3560  for (NTV2AudioSystemSetConstIter it(inObj.begin()); it != inObj.end(); )
3561  {
3562  if (inCompact)
3563  inOutStream << DEC(*it+1);
3564  else
3565  inOutStream << ::NTV2AudioSystemToString(*it);
3566  if (++it != inObj.end())
3567  inOutStream << (inCompact ? "|" : ",");
3568  }
3569  return inOutStream << "}";
3570 }
3571 
3572 string NTV2AudioSystemSetToStr (const NTV2AudioSystemSet & inObj, const bool inCompact)
3573 { ostringstream oss;
3574  ::NTV2PrintAudioSystemSet (inObj, inCompact, oss);
3575  return oss.str();
3576 }
3577 
3578 NTV2AudioSystemSet NTV2MakeAudioSystemSet (const NTV2AudioSystem inFirstAudioSystem, const UWord inCount)
3579 {
3580  NTV2AudioSystemSet result;
3581  for (NTV2AudioSystem audSys(inFirstAudioSystem); audSys < NTV2AudioSystem(inFirstAudioSystem+inCount); audSys = NTV2AudioSystem(audSys+1))
3582  if (NTV2_IS_VALID_AUDIO_SYSTEM(audSys))
3583  result.insert(audSys);
3584  return result;
3585 }
3586 
3587 NTV2RegNumSet GetRegisterNumbers (const NTV2RegReads & inRegInfos)
3588 {
3589  NTV2RegNumSet result;
3590  for (NTV2RegisterReadsConstIter it(inRegInfos.begin()); it != inRegInfos.end(); ++it)
3591  if (result.find(it->registerNumber) == result.end())
3592  result.insert(it->registerNumber);
3593  return result;
3594 }
3595 
3596 NTV2RegisterReadsConstIter FindFirstMatchingRegisterNumber (const uint32_t inRegNum, const NTV2RegisterReads & inRegInfos)
3597 {
3598  for (NTV2RegisterReadsConstIter iter(inRegInfos.begin()); iter != inRegInfos.end(); ++iter) // Ugh -- linear search
3599  if (iter->registerNumber == inRegNum)
3600  return iter;
3601  return inRegInfos.end();
3602 }
3603 
3604 
3605 ostream & operator << (std::ostream & inOutStream, const NTV2RegInfo & inObj)
3606 {
3607  return inObj.Print(inOutStream);
3608 }
3609 
3610 
3611 ostream & operator << (ostream & inOutStream, const NTV2RegisterWrites & inObj)
3612 {
3613  inOutStream << inObj.size () << " regs:" << endl;
3614  for (NTV2RegisterWritesConstIter iter (inObj.begin ()); iter != inObj.end (); ++iter)
3615  inOutStream << *iter << endl;
3616  return inOutStream;
3617 }
3618 
3619 
3620 NTV2BankSelGetSetRegs::NTV2BankSelGetSetRegs (const NTV2RegInfo & inBankSelect, const NTV2RegInfo & inOutRegInfo, const bool inDoWrite)
3621  : mHeader (NTV2_TYPE_BANKGETSET, sizeof (NTV2BankSelGetSetRegs)),
3622  mIsWriting (inDoWrite), // Default to reading
3623  mInBankInfos (sizeof(NTV2RegInfo)), // Room for one bank select
3624  mInRegInfos (sizeof(NTV2RegInfo)) // Room for one register read or write
3625 {
3626  NTV2RegInfo * pRegInfo (mInBankInfos);
3627  if (pRegInfo)
3628  *pRegInfo = inBankSelect; // Store bank select regInfo
3629  pRegInfo = mInRegInfos;
3630  if (pRegInfo)
3631  *pRegInfo = inOutRegInfo; // Store regInfo
3632  NTV2_ASSERT_STRUCT_VALID;
3633 }
3634 
3635 
3636 NTV2RegInfo NTV2BankSelGetSetRegs::GetRegInfo (const UWord inIndex0) const
3637 {
3638  NTV2_ASSERT_STRUCT_VALID;
3639  NTV2RegInfo result;
3640  if (mInRegInfos)
3641  {
3642  const NTV2RegInfo * pRegInfos (mInRegInfos);
3643  const ULWord maxNum (mInRegInfos.GetByteCount() / ULWord(sizeof(NTV2RegInfo)));
3644  if (ULWord(inIndex0) < maxNum)
3645  result = pRegInfos[inIndex0];
3646  }
3647  return result;
3648 }
3649 
3650 
3651 ostream & NTV2BankSelGetSetRegs::Print (ostream & oss) const
3652 {
3653  NTV2_ASSERT_STRUCT_VALID;
3654  const NTV2RegInfo * pBankRegInfo (mInBankInfos);
3655  const NTV2RegInfo * pRegInfo (mInRegInfos);
3656  oss << mHeader << (mIsWriting ? " WRIT" : " READ") << " bankReg=";
3657  if (mInBankInfos) oss << *pBankRegInfo; else oss << "-";
3658  oss << " regInfos=";
3659  if (mInRegInfos) oss << *pRegInfo; else oss << "-";
3660  return oss;
3661 }
3662 
3663 
3664 NTV2VirtualData::NTV2VirtualData (const ULWord inTag, const void* inVirtualData, const size_t inVirtualDataSize, const bool inDoWrite)
3665  : mHeader (NTV2_TYPE_VIRTUAL_DATA_RW, sizeof (NTV2VirtualData)),
3666  mTag (inTag), // setup tag
3667  mIsWriting (inDoWrite), // setup write/read
3668  mVirtualData (inVirtualData, inVirtualDataSize) // setup virtual data
3669 {
3670  NTV2_ASSERT_STRUCT_VALID;
3671 }
3672 
3673 
3674 ostream & NTV2VirtualData::Print (ostream & inOutStream) const
3675 {
3676  NTV2_ASSERT_STRUCT_VALID;
3677  inOutStream << mHeader << ", mTag=" << mTag << ", mIsWriting=" << mIsWriting;
3678  return inOutStream;
3679 }
3680 
3681 using namespace ntv2nub;
3682 
3683  /*********************************************************************************************************************
3684  RPC ENCODE/DECODE FUNCTIONS
3685  *********************************************************************************************************************/
3686  #define AsU8Ref(_x_) reinterpret_cast<uint8_t&>(_x_)
3687  #define AsU16Ref(_x_) reinterpret_cast<uint16_t&>(_x_)
3688  #define AsU32Ref(_x_) reinterpret_cast<uint32_t&>(_x_)
3689  #define AsU64Ref(_x_) reinterpret_cast<uint64_t&>(_x_)
3690 
3691  bool NTV2_HEADER::RPCEncode (UByteSequence & outBlob)
3692  {
3693  PUSHU32(fHeaderTag, outBlob); // ULWord fHeaderTag
3694  PUSHU32(fType, outBlob); // ULWord fType
3695  PUSHU32(fHeaderVersion, outBlob); // ULWord fHeaderVersion
3696  PUSHU32(fVersion, outBlob); // ULWord fVersion
3697  PUSHU32(fSizeInBytes, outBlob); // ULWord fSizeInBytes
3698  PUSHU32(fPointerSize, outBlob); // ULWord fPointerSize
3699  PUSHU32(fOperation, outBlob); // ULWord fOperation
3700  PUSHU32(fResultStatus, outBlob); // ULWord fResultStatus
3701  return true;
3702  }
3703 
3704  bool NTV2_HEADER::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3705  {
3706  POPU32(fHeaderTag, inBlob, inOutIndex); // ULWord fHeaderTag
3707  POPU32(fType, inBlob, inOutIndex); // ULWord fType
3708  POPU32(fHeaderVersion, inBlob, inOutIndex); // ULWord fHeaderVersion
3709  POPU32(fVersion, inBlob, inOutIndex); // ULWord fVersion
3710  POPU32(fSizeInBytes, inBlob, inOutIndex); // ULWord fSizeInBytes
3711  POPU32(fPointerSize, inBlob, inOutIndex); // ULWord fPointerSize
3712  POPU32(fOperation, inBlob, inOutIndex); // ULWord fOperation
3713  POPU32(fResultStatus, inBlob, inOutIndex); // ULWord fResultStatus
3714  return true;
3715  }
3716 
3717  bool NTV2_TRAILER::RPCEncode (UByteSequence & outBlob)
3718  {
3719  PUSHU32(fTrailerVersion, outBlob); // ULWord fTrailerVersion
3720  PUSHU32(fTrailerTag, outBlob); // ULWord fTrailerTag
3721  return true;
3722  }
3723 
3724  bool NTV2_TRAILER::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3725  {
3726  POPU32(fTrailerVersion, inBlob, inOutIndex); // ULWord fTrailerVersion
3727  POPU32(fTrailerTag, inBlob, inOutIndex); // ULWord fTrailerTag
3728  return true;
3729  }
3730 
3731 
3732  bool NTV2Buffer::RPCEncode (UByteSequence & outBlob)
3733  {
3734  PUSHU32(fByteCount, outBlob); // ULWord fByteCount
3735  PUSHU32(fFlags, outBlob); // ULWord fFlags
3736  if (!IsNULL())
3737  AppendU8s(outBlob); // NOTE: My buffer content should already have been made BigEndian, if necessary
3738  return true;
3739  }
3740 
3741  bool NTV2Buffer::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3742  {
3743  ULWord byteCount(0), flags(0);
3744  POPU32(byteCount, inBlob, inOutIndex); // ULWord fByteCount
3745  POPU32(flags, inBlob, inOutIndex); // ULWord fFlags
3746  if (!Allocate(byteCount, flags & NTV2Buffer_PAGE_ALIGNED))
3747  return false;
3748  if ((inOutIndex + byteCount) > inBlob.size())
3749  return false; // past end of inBlob
3750  for (ULWord cnt(0); cnt < byteCount; cnt++)
3751  U8(int(cnt)) = inBlob.at(inOutIndex++); // Caller is responsible for byte-swapping if needed
3752  return true;
3753  }
3754 
3755  bool NTV2GetRegisters::RPCEncode (UByteSequence & outBlob)
3756  {
3757  const size_t totBytes (mHeader.GetSizeInBytes() // Header + natural size of all structs/fields inbetween + Trailer
3758  + mInRegisters.GetByteCount() + mOutGoodRegisters.GetByteCount() + mOutValues.GetByteCount()); // NTV2Buffer fields
3759  if (outBlob.capacity() < totBytes)
3760  outBlob.reserve(totBytes);
3761  if (!NTV2HostIsBigEndian)
3762  { // All of my NTV2Buffers store arrays of ULWords that must be BigEndian BEFORE encoding into outBlob...
3763  mInRegisters.ByteSwap32();
3764  mOutGoodRegisters.ByteSwap32();
3765  mOutValues.ByteSwap32();
3766  }
3767  bool ok = mHeader.RPCEncode(outBlob); // NTV2_HEADER mHeader
3768  PUSHU32(mInNumRegisters, outBlob); // ULWord mInNumRegisters
3769  ok &= mInRegisters.RPCEncode(outBlob); // NTV2Buffer mInRegisters
3770  PUSHU32(mOutNumRegisters, outBlob); // ULWord mOutNumRegisters
3771  ok &= mOutGoodRegisters.RPCEncode(outBlob) // NTV2Buffer mOutGoodRegisters
3772  && mOutValues.RPCEncode(outBlob) // NTV2Buffer mOutValues
3773  && mTrailer.RPCEncode(outBlob); // NTV2_TRAILER mTrailer
3774  if (!NTV2HostIsBigEndian && !ok)
3775  { // FAILED: Un-byteswap NTV2Buffer data...
3776  mInRegisters.ByteSwap32();
3777  mOutGoodRegisters.ByteSwap32();
3778  mOutValues.ByteSwap32();
3779  }
3780  return ok;
3781  }
3782 
3783  bool NTV2GetRegisters::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3784  {
3785  bool ok = mHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER mHeader
3786  if (!ok) return false;
3787  POPU32(mInNumRegisters, inBlob, inOutIndex); // ULWord mInNumRegisters
3788  ok &= mInRegisters.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mInRegisters
3789  POPU32(mOutNumRegisters, inBlob, inOutIndex); // ULWord mOutNumRegisters
3790  ok &= mOutGoodRegisters.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mOutGoodRegisters
3791  ok &= mOutValues.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mOutValues
3792  ok &= mTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER mTrailer
3793  if (!NTV2HostIsBigEndian)
3794  { // Re-byteswap NTV2Buffer data after decoding...
3795  mInRegisters.ByteSwap32();
3796  mOutGoodRegisters.ByteSwap32();
3797  mOutValues.ByteSwap32();
3798  }
3799  return ok;
3800  }
3801 
3802  bool NTV2SetRegisters::RPCEncode (UByteSequence & outBlob)
3803  {
3804  const size_t totBytes (mHeader.GetSizeInBytes() // Header + natural size of all structs/fields inbetween + Trailer
3805  + mInRegInfos.GetByteCount() + mOutBadRegIndexes.GetByteCount()); // NTV2Buffer fields
3806  if (outBlob.capacity() < totBytes)
3807  outBlob.reserve(totBytes);
3808  if (!NTV2HostIsBigEndian)
3809  { // All of my NTV2Buffers store arrays of ULWords that must be BigEndian BEFORE encoding into outBlob...
3810  mInRegInfos.ByteSwap32();
3811  mOutBadRegIndexes.ByteSwap32();
3812  }
3813  bool ok = mHeader.RPCEncode(outBlob); // NTV2_HEADER mHeader
3814  PUSHU32(mInNumRegisters, outBlob); // ULWord mInNumRegisters
3815  ok &= mInRegInfos.RPCEncode(outBlob); // NTV2Buffer mInRegInfos
3816  PUSHU32(mOutNumFailures, outBlob); // ULWord mOutNumFailures
3817  ok &= mOutBadRegIndexes.RPCEncode(outBlob) // NTV2Buffer mOutBadRegIndexes
3818  && mTrailer.RPCEncode(outBlob); // NTV2_TRAILER mTrailer
3819  if (!NTV2HostIsBigEndian && !ok)
3820  { // FAILED: Un-byteswap NTV2Buffer data...
3821  mInRegInfos.ByteSwap32();
3822  mOutBadRegIndexes.ByteSwap16();
3823  }
3824  return ok;
3825  }
3826 
3827  bool NTV2SetRegisters::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3828  {
3829  bool ok = mHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER mHeader
3830  POPU32(mInNumRegisters, inBlob, inOutIndex); // ULWord mInNumRegisters
3831  ok &= mInRegInfos.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mInRegInfos
3832  POPU32(mOutNumFailures, inBlob, inOutIndex); // ULWord mOutNumFailures
3833  ok &= mOutBadRegIndexes.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mOutBadRegIndexes
3834  ok &= mTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER mTrailer
3835  if (!NTV2HostIsBigEndian)
3836  { // Re-byteswap NTV2Buffer data after decoding...
3837  mInRegInfos.ByteSwap32();
3838  mOutBadRegIndexes.ByteSwap16();
3839  }
3840  return ok;
3841  }
3842 
3843  bool NTV2BankSelGetSetRegs::RPCEncode (UByteSequence & outBlob)
3844  {
3845  const size_t totBytes (mHeader.GetSizeInBytes() // Header + natural size of all structs/fields inbetween + Trailer
3846  + mInBankInfos.GetByteCount() + mInRegInfos.GetByteCount()); // NTV2Buffer fields
3847  if (outBlob.capacity() < totBytes)
3848  outBlob.reserve(totBytes);
3849  if (!NTV2HostIsBigEndian)
3850  { // All of my NTV2Buffers store arrays of ULWords that must be BigEndian BEFORE encoding into outBlob...
3851  mInBankInfos.ByteSwap32();
3852  mInRegInfos.ByteSwap32();
3853  }
3854  bool ok = mHeader.RPCEncode(outBlob); // NTV2_HEADER mHeader
3855  PUSHU32(mIsWriting, outBlob); // ULWord mIsWriting
3856  ok &= mInBankInfos.RPCEncode(outBlob); // NTV2Buffer mInBankInfos
3857  ok &= mInRegInfos.RPCEncode(outBlob) // NTV2Buffer mInRegInfos
3858  && mTrailer.RPCEncode(outBlob); // NTV2_TRAILER mTrailer
3859  if (!NTV2HostIsBigEndian && !ok)
3860  { // FAILED: Un-byteswap NTV2Buffer data...
3861  mInBankInfos.ByteSwap32();
3862  mInRegInfos.ByteSwap32();
3863  }
3864  return ok;
3865  }
3866 
3867  bool NTV2BankSelGetSetRegs::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3868  {
3869  bool ok = mHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER mHeader
3870  POPU32(mIsWriting, inBlob, inOutIndex); // ULWord mIsWriting
3871  ok &= mInBankInfos.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mInBankInfos
3872  ok &= mInRegInfos.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mInRegInfos
3873  ok &= mTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER mTrailer
3874  if (!NTV2HostIsBigEndian)
3875  { // Re-byteswap NTV2Buffer data after decoding...
3876  mInBankInfos.ByteSwap32();
3877  mInRegInfos.ByteSwap32();
3878  }
3879  return ok;
3880  }
3881 
3882  bool AUTOCIRCULATE_STATUS::RPCEncode (UByteSequence & outBlob)
3883  {
3884  const size_t totBytes (acHeader.GetSizeInBytes()); // Header + natural size of all structs/fields inbetween + Trailer
3885  if (outBlob.capacity() < totBytes)
3886  outBlob.reserve(totBytes);
3887  bool ok = acHeader.RPCEncode(outBlob); // NTV2_HEADER acHeader
3888  PUSHU16(UWord(acCrosspoint), outBlob); // NTV2Crosspoint acCrosspoint
3889  PUSHU16(UWord(acState), outBlob); // NTV2AutoCirculateState acState
3890  PUSHU32(ULWord(acStartFrame), outBlob); // LWord acStartFrame
3891  PUSHU32(ULWord(acEndFrame), outBlob); // LWord acEndFrame
3892  PUSHU32(ULWord(acActiveFrame), outBlob); // LWord acActiveFrame
3893  PUSHU64(acRDTSCStartTime, outBlob); // ULWord64 acRDTSCStartTime
3894  PUSHU64(acAudioClockStartTime, outBlob); // ULWord64 acAudioClockStartTime
3895  PUSHU64(acRDTSCCurrentTime, outBlob); // ULWord64 acRDTSCCurrentTime
3896  PUSHU64(acAudioClockCurrentTime, outBlob); // ULWord64 acAudioClockCurrentTime
3897  PUSHU32(acFramesProcessed, outBlob); // ULWord acFramesProcessed
3898  PUSHU32(acFramesDropped, outBlob); // ULWord acFramesDeopped
3899  PUSHU32(acBufferLevel, outBlob); // ULWord acBufferLevel
3900  PUSHU32(acOptionFlags, outBlob); // ULWord acOptionFlags
3901  PUSHU16(UWord(acAudioSystem), outBlob); // NTV2AudioSystem acAudioSystem
3902  ok &= acTrailer.RPCEncode(outBlob); // NTV2_TRAILER acTrailer
3903  return ok;
3904  }
3905 
3906  bool AUTOCIRCULATE_STATUS::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3907  { uint16_t v16(0); uint32_t v32(0);
3908  bool ok = acHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER acHeader
3909  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint acCrosspoint
3910  acCrosspoint = NTV2Crosspoint(v16);
3911  POPU16(v16, inBlob, inOutIndex); // NTV2AutoCirculateState acState
3912  acState = NTV2AutoCirculateState(v16);
3913  POPU32(v32, inBlob, inOutIndex); // LWord acStartFrame
3914  acStartFrame = LWord(v32);
3915  POPU32(v32, inBlob, inOutIndex); // LWord acEndFrame
3916  acEndFrame = LWord(v32);
3917  POPU32(v32, inBlob, inOutIndex); // LWord acActiveFrame
3918  acActiveFrame = LWord(v32);
3919  POPU64(acRDTSCStartTime, inBlob, inOutIndex); // ULWord64 acRDTSCStartTime
3920  POPU64(acAudioClockStartTime, inBlob, inOutIndex); // ULWord64 acAudioClockStartTime
3921  POPU64(acRDTSCCurrentTime, inBlob, inOutIndex); // ULWord64 acRDTSCCurrentTime
3922  POPU64(acAudioClockCurrentTime, inBlob, inOutIndex); // ULWord64 acAudioClockCurrentTime
3923  POPU32(acFramesProcessed, inBlob, inOutIndex); // ULWord acFramesProcessed
3924  POPU32(acFramesDropped, inBlob, inOutIndex); // ULWord acFramesDropped
3925  POPU32(acBufferLevel, inBlob, inOutIndex); // ULWord acBufferLevel
3926  POPU32(acOptionFlags, inBlob, inOutIndex); // ULWord acOptionFlags
3927  POPU16(v16, inBlob, inOutIndex); // NTV2AudioSystem acAudioSystem
3928  acAudioSystem = NTV2AudioSystem(v16);
3929  ok &= acTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER acTrailer
3930  return ok;
3931  }
3932 
3933  bool FRAME_STAMP::RPCEncode (UByteSequence & outBlob)
3934  {
3935  const size_t totBytes (acHeader.GetSizeInBytes()); // Header + natural size of all structs/fields inbetween + Trailer
3936  if (outBlob.capacity() < totBytes)
3937  outBlob.reserve(totBytes);
3938  bool ok = acHeader.RPCEncode(outBlob); // NTV2_HEADER acHeader
3939  PUSHU64(ULWord64(acFrameTime), outBlob); // LWord64 acFrameTime
3940  PUSHU32(acRequestedFrame, outBlob); // ULWord acRequestedFrame
3941  PUSHU64(acAudioClockTimeStamp, outBlob); // ULWord64 acAudioClockTimeStamp
3942  PUSHU32(acAudioExpectedAddress, outBlob); // ULWord acAudioExpectedAddress
3943  PUSHU32(acAudioInStartAddress, outBlob); // ULWord acAudioInStartAddress
3944  PUSHU32(acAudioInStopAddress, outBlob); // ULWord acAudioInStopAddress
3945  PUSHU32(acAudioOutStopAddress, outBlob); // ULWord acAudioOutStopAddress
3946  PUSHU32(acAudioOutStartAddress, outBlob); // ULWord acAudioOutStartAddress
3947  PUSHU32(acTotalBytesTransferred, outBlob); // ULWord acTotalBytesTransferred
3948  PUSHU32(acStartSample, outBlob); // ULWord acStartSample
3949 
3950  ok &= acTimeCodes.RPCEncode(outBlob); // NTV2Buffer acTimeCodes
3951  PUSHU64(ULWord64(acCurrentTime), outBlob); // LWord64 acCurrentTime
3952  PUSHU32(acCurrentFrame, outBlob); // ULWord acCurrentFrame
3953  PUSHU64(ULWord64(acCurrentFrameTime), outBlob); // LWord64 acCurrentFrameTime
3954  PUSHU64(acAudioClockCurrentTime, outBlob); // ULWord64 acAudioClockCurrentTime
3955  PUSHU32(acCurrentAudioExpectedAddress, outBlob); // ULWord acCurrentAudioExpectedAddress
3956  PUSHU32(acCurrentAudioStartAddress, outBlob); // ULWord acCurrentAudioStartAddress
3957  PUSHU32(acCurrentFieldCount, outBlob); // ULWord acCurrentFieldCount
3958  PUSHU32(acCurrentLineCount, outBlob); // ULWord acCurrentLineCount
3959  PUSHU32(acCurrentReps, outBlob); // ULWord acCurrentReps
3960  PUSHU64(acCurrentUserCookie, outBlob); // ULWord64 acCurrentUserCookie
3961  PUSHU32(acFrame, outBlob); // ULWord acFrame
3962  PUSHU32(acRP188.fDBB, outBlob); // ULWord acRP188.fDBB
3963  PUSHU32(acRP188.fLo, outBlob); // ULWord acRP188.fLo
3964  PUSHU32(acRP188.fHi, outBlob); // ULWord acRP188.fHi
3965  ok &= acTrailer.RPCEncode(outBlob); // NTV2_TRAILER acTrailer
3966  return ok;
3967  }
3968 
3969  bool FRAME_STAMP::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
3970  { uint64_t v64(0);
3971  bool ok = acHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER acHeader
3972  POPU64(v64, inBlob, inOutIndex); // LWord64 acFrameTime
3973  acFrameTime = LWord64(v64);
3974  POPU32(acRequestedFrame, inBlob, inOutIndex); // ULWord acRequestedFrame
3975  POPU64(acAudioClockTimeStamp, inBlob, inOutIndex); // ULWord64 acAudioClockTimeStamp
3976  POPU32(acAudioExpectedAddress, inBlob, inOutIndex); // ULWord acAudioExpectedAddress
3977  POPU32(acAudioInStartAddress, inBlob, inOutIndex); // ULWord acAudioInStartAddress
3978  POPU32(acAudioInStopAddress, inBlob, inOutIndex); // ULWord acAudioInStopAddress
3979  POPU32(acAudioOutStopAddress, inBlob, inOutIndex); // ULWord acAudioOutStopAddress
3980  POPU32(acAudioOutStartAddress, inBlob, inOutIndex); // ULWord acAudioOutStartAddress
3981  POPU32(acTotalBytesTransferred, inBlob, inOutIndex); // ULWord acTotalBytesTransferred
3982  POPU32(acStartSample, inBlob, inOutIndex); // ULWord acStartSample
3983 
3984  ok &= acTimeCodes.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acTimeCodes
3985  POPU64(v64, inBlob, inOutIndex); // LWord64 acCurrentTime
3986  acCurrentTime = LWord64(v64);
3987  POPU32(acCurrentFrame, inBlob, inOutIndex); // ULWord acCurrentFrame
3988  POPU64(v64, inBlob, inOutIndex); // LWord64 acCurrentFrameTime
3989  acCurrentFrameTime = LWord64(v64);
3990  POPU64(acAudioClockCurrentTime, inBlob, inOutIndex); // ULWord64 acAudioClockCurrentTime
3991  POPU32(acCurrentAudioExpectedAddress, inBlob, inOutIndex); // ULWord acCurrentAudioExpectedAddress
3992  POPU32(acCurrentAudioStartAddress, inBlob, inOutIndex); // ULWord acCurrentAudioStartAddress
3993  POPU32(acCurrentFieldCount, inBlob, inOutIndex); // ULWord acCurrentFieldCount
3994  POPU32(acCurrentLineCount, inBlob, inOutIndex); // ULWord acCurrentLineCount
3995  POPU32(acCurrentReps, inBlob, inOutIndex); // ULWord acCurrentReps
3996  POPU64(acCurrentUserCookie, inBlob, inOutIndex); // ULWord64 acCurrentUserCookie
3997  POPU32(acFrame, inBlob, inOutIndex); // ULWord acFrame
3998  POPU32(acRP188.fDBB, inBlob, inOutIndex); // ULWord acRP188.fDBB
3999  POPU32(acRP188.fLo, inBlob, inOutIndex); // ULWord acRP188.fLo
4000  POPU32(acRP188.fHi, inBlob, inOutIndex); // ULWord acRP188.fHi
4001  ok &= acTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER acTrailer
4002  return ok;
4003  }
4004 
4005  bool AUTOCIRCULATE_TRANSFER_STATUS::RPCEncode (UByteSequence & outBlob)
4006  {
4007  const size_t totBytes (acHeader.GetSizeInBytes()); // Header + natural size of all structs/fields inbetween + Trailer
4008  if (outBlob.capacity() < totBytes)
4009  outBlob.reserve(totBytes);
4010  bool ok = acHeader.RPCEncode(outBlob); // NTV2_HEADER acHeader
4011  PUSHU16(acState, outBlob); // UWord acState
4012  PUSHU32(ULWord(acTransferFrame), outBlob); // LWord acTransferFrame
4013  PUSHU32(acBufferLevel, outBlob); // ULWord acBufferLevel
4014  PUSHU32(acFramesProcessed, outBlob); // ULWord acFramesProcessed
4015  PUSHU32(acFramesDropped, outBlob); // ULWord acFramesDropped
4016  ok &= acFrameStamp.RPCEncode(outBlob); // FRAME_STAMP acFrameStamp
4017  PUSHU32(acAudioTransferSize, outBlob); // ULWord acAudioTransferSize
4018  PUSHU32(acAudioStartSample, outBlob); // ULWord acAudioStartSample
4019  PUSHU32(acAncTransferSize, outBlob); // ULWord acAncTransferSize
4020  PUSHU32(acAncField2TransferSize, outBlob); // ULWord acAncField2TransferSize
4021  ok &= acTrailer.RPCEncode(outBlob); // NTV2_TRAILER acTrailer
4022  return ok;
4023  }
4024 
4025  bool AUTOCIRCULATE_TRANSFER_STATUS::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4026  { uint16_t v16(0); uint32_t v32(0);
4027  bool ok = acHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER acHeader
4028  POPU16(v16, inBlob, inOutIndex); // NTV2AutoCirculateState acState
4029  acState = NTV2AutoCirculateState(v16);
4030  POPU32(v32, inBlob, inOutIndex); // LWord acTransferFrame
4031  acTransferFrame = LWord(v32);
4032  POPU32(acBufferLevel, inBlob, inOutIndex); // ULWord acBufferLevel
4033  POPU32(acFramesProcessed, inBlob, inOutIndex); // ULWord acFramesProcessed
4034  POPU32(acFramesDropped, inBlob, inOutIndex); // ULWord acFramesDropped
4035  ok &= acFrameStamp.RPCDecode(inBlob, inOutIndex); // FRAME_STAMP acFrameStamp
4036  POPU32(acAudioTransferSize, inBlob, inOutIndex); // ULWord acAudioTransferSize
4037  POPU32(acAudioStartSample, inBlob, inOutIndex); // ULWord acAudioStartSample
4038  POPU32(acAncTransferSize, inBlob, inOutIndex); // ULWord acAncTransferSize
4039  POPU32(acAncField2TransferSize, inBlob, inOutIndex); // ULWord acAncField2TransferSize
4040  ok &= acTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER acTrailer
4041  return ok;
4042  }
4043 
4044  bool NTV2SegmentedDMAInfo::RPCEncode (UByteSequence & outBlob)
4045  {
4046  PUSHU32(acNumSegments, outBlob); // ULWord acNumSegments
4047  PUSHU32(acNumActiveBytesPerRow, outBlob); // ULWord acNumActiveBytesPerRow
4048  PUSHU32(acSegmentHostPitch, outBlob); // ULWord acSegmentHostPitch
4049  PUSHU32(acSegmentDevicePitch, outBlob); // ULWord acSegmentDevicePitch
4050  return true;
4051  }
4052 
4053  bool NTV2SegmentedDMAInfo::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4054  {
4055  POPU32(acNumSegments, inBlob, inOutIndex); // ULWord acNumSegments
4056  POPU32(acNumActiveBytesPerRow, inBlob, inOutIndex); // ULWord acNumActiveBytesPerRow
4057  POPU32(acSegmentHostPitch, inBlob, inOutIndex); // ULWord acSegmentHostPitch
4058  POPU32(acSegmentDevicePitch, inBlob, inOutIndex); // ULWord acSegmentDevicePitch
4059  return true;
4060  }
4061 
4062  bool NTV2ColorCorrectionData::RPCEncode (UByteSequence & outBlob)
4063  {
4064  PUSHU16(ccMode, outBlob); // NTV2ColorCorrectionMode ccMode
4065  PUSHU32(ccSaturationValue, outBlob); // ULWord ccSaturationValue
4066  return ccLookupTables.RPCEncode(outBlob); // NTV2Buffer ccLookupTables
4067  }
4068 
4069  bool NTV2ColorCorrectionData::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4070  { uint16_t u16(0);
4071  POPU16(u16, inBlob, inOutIndex); // NTV2ColorCorrectionMode ccMode
4072  ccMode = NTV2ColorCorrectionMode(u16);
4073  POPU32(ccSaturationValue, inBlob, inOutIndex); // ULWord ccSaturationValue
4074  return ccLookupTables.RPCDecode(inBlob, inOutIndex); // NTV2Buffer ccLookupTables
4075  }
4076 
4077  bool AutoCircVidProcInfo::RPCEncode (UByteSequence & outBlob)
4078  {
4079  PUSHU16(mode, outBlob); // AutoCircVidProcMode mode
4080  PUSHU16(foregroundVideoCrosspoint, outBlob); // NTV2Crosspoint foregroundVideoCrosspoint
4081  PUSHU16(backgroundVideoCrosspoint, outBlob); // NTV2Crosspoint backgroundVideoCrosspoint
4082  PUSHU16(foregroundKeyCrosspoint, outBlob); // NTV2Crosspoint foregroundKeyCrosspoint
4083  PUSHU16(backgroundKeyCrosspoint, outBlob); // NTV2Crosspoint backgroundKeyCrosspoint
4084  PUSHU32(ULWord(transitionCoefficient), outBlob); // Fixed_ transitionCoefficient
4085  PUSHU32(ULWord(transitionSoftness), outBlob); // Fixed_ transitionSoftness
4086  return true;
4087  }
4088 
4089  bool AutoCircVidProcInfo::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4090  { uint16_t v16(0); uint32_t v32(0);
4091  POPU16(v16, inBlob, inOutIndex); // AutoCircVidProcMode mode
4092  mode = AutoCircVidProcMode(v16);
4093  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint foregroundVideoCrosspoint
4094  foregroundVideoCrosspoint = NTV2Crosspoint(v16);
4095  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint backgroundVideoCrosspoint
4096  backgroundVideoCrosspoint = NTV2Crosspoint(v16);
4097  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint foregroundKeyCrosspoint
4098  foregroundKeyCrosspoint = NTV2Crosspoint(v16);
4099  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint backgroundKeyCrosspoint
4100  backgroundKeyCrosspoint = NTV2Crosspoint(v16);
4101  POPU32(v32, inBlob, inOutIndex); // Fixed_ transitionCoefficient
4102  transitionCoefficient = Fixed_(v32);
4103  POPU32(v32, inBlob, inOutIndex); // Fixed_ transitionSoftness
4104  transitionSoftness = Fixed_(v32);
4105  return true;
4106  }
4107 
4108  bool NTV2_RP188::RPCEncode (UByteSequence & outBlob)
4109  {
4110  PUSHU32(fDBB, outBlob); // ULWord fDBB
4111  PUSHU32(fLo, outBlob); // ULWord fLo
4112  PUSHU32(fHi, outBlob); // ULWord fHi
4113  return true;
4114  }
4115 
4116  bool NTV2_RP188::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4117  {
4118  POPU32(fDBB, inBlob, inOutIndex); // ULWord fDBB
4119  POPU32(fLo, inBlob, inOutIndex); // ULWord fLo
4120  POPU32(fHi, inBlob, inOutIndex); // ULWord fHi
4121  return true;
4122  }
4123 
4124  bool AUTOCIRCULATE_TRANSFER::RPCEncode (UByteSequence & outBlob)
4125  {
4126  AJADebug::StatTimerStart(AJA_DebugStat_ACXferRPCEncode);
4127  const size_t totBytes (acHeader.GetSizeInBytes() + acVideoBuffer.GetByteCount() + acAudioBuffer.GetByteCount()
4128  + acANCBuffer.GetByteCount() + acANCField2Buffer.GetByteCount() + acOutputTimeCodes.GetByteCount()
4129  + acHDMIAuxData.GetByteCount() + 64); // Header + natural size of all structs/fields inbetween + Trailer
4130  if (outBlob.capacity() < totBytes)
4131  outBlob.reserve(totBytes);
4132  bool ok = acHeader.RPCEncode(outBlob); // NTV2_HEADER acHeader
4133  ok &= acVideoBuffer.RPCEncode(outBlob); // NTV2Buffer acVideoBuffer
4134  ok &= acAudioBuffer.RPCEncode(outBlob); // NTV2Buffer acAudioBuffer
4135  ok &= acANCBuffer.RPCEncode(outBlob); // NTV2Buffer acANCBuffer
4136  ok &= acANCField2Buffer.RPCEncode(outBlob); // NTV2Buffer acANCField2Buffer
4137  ok &= acOutputTimeCodes.RPCEncode(outBlob); // NTV2Buffer acOutputTimeCodes
4138  ok &= acTransferStatus.RPCEncode(outBlob); // AUTOCIRCULATE_TRANSFER_STATUS acTransferStatus
4139  PUSHU64(acInUserCookie, outBlob); // ULWord64 acInUserCookie
4140  PUSHU32(acInVideoDMAOffset, outBlob); // ULWord acInVideoDMAOffset
4141  ok &= acInSegmentedDMAInfo.RPCEncode(outBlob); // NTV2SegmentedDMAInfo acInSegmentedDMAInfo
4142  ok &= acColorCorrection.RPCEncode(outBlob); // NTV2ColorCorrectionData acColorCorrection
4143  PUSHU16(acFrameBufferFormat, outBlob); // NTV2PixelFormat acFrameBufferFormat
4144  PUSHU16(acFrameBufferOrientation, outBlob); // NTV2FBOrientation acFrameBufferOrientation
4145  ok &= acVidProcInfo.RPCEncode(outBlob); // AutoCircVidProcInfo acVidProcInfo
4146  PUSHU16(acVideoQuarterSizeExpand, outBlob); // NTV2QtrSizeExpandMode acVideoQuarterSizeExpand
4147  ok &= acHDMIAuxData.RPCEncode(outBlob); // NTV2Buffer acHDMIAuxData
4148  PUSHU32(acPeerToPeerFlags, outBlob); // ULWord acPeerToPeerFlags
4149  PUSHU32(acFrameRepeatCount, outBlob); // ULWord acFrameRepeatCount
4150  PUSHU32(ULWord(acDesiredFrame), outBlob); // LWord acDesiredFrame
4151  ok &= acRP188.RPCEncode(outBlob); // NTV2_RP188 acRP188
4152  PUSHU16(acCrosspoint, outBlob); // NTV2Crosspoint acCrosspoint
4153  ok &= acTrailer.RPCEncode(outBlob); // NTV2_TRAILER acTrailer
4154  AJADebug::StatTimerStop(AJA_DebugStat_ACXferRPCEncode);
4155  return ok;
4156  }
4157 
4158  bool AUTOCIRCULATE_TRANSFER::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4159  { uint16_t v16(0); uint32_t v32(0);
4160  AJADebug::StatTimerStart(AJA_DebugStat_ACXferRPCDecode);
4161  bool ok = acHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER acHeader
4162  ok &= acVideoBuffer.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acVideoBuffer
4163  ok &= acAudioBuffer.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acAudioBuffer
4164  ok &= acANCBuffer.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acANCBuffer
4165  ok &= acANCField2Buffer.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acANCField2Buffer
4166  ok &= acOutputTimeCodes.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acOutputTimeCodes
4167  ok &= acTransferStatus.RPCDecode(inBlob, inOutIndex); // AUTOCIRCULATE_TRANSFER_STATUS acTransferStatus
4168  POPU64(acInUserCookie, inBlob, inOutIndex); // ULWord64 acInUserCookie
4169  POPU32(acInVideoDMAOffset, inBlob, inOutIndex); // ULWord acInVideoDMAOffset
4170  ok &= acInSegmentedDMAInfo.RPCDecode(inBlob, inOutIndex);// NTV2Buffer acInSegmentedDMAInfo
4171  ok &= acColorCorrection.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acColorCorrection
4172  POPU16(v16, inBlob, inOutIndex); // NTV2PixelFormat acFrameBufferFormat
4173  acFrameBufferFormat = NTV2FrameBufferFormat(v16);
4174  POPU16(v16, inBlob, inOutIndex); // NTV2FBOrientation acFrameBufferOrientation
4175  acFrameBufferOrientation = NTV2FBOrientation(v16);
4176  ok &= acVidProcInfo.RPCDecode(inBlob, inOutIndex); // AutoCircVidProcInfo acVidProcInfo
4177  POPU16(v16, inBlob, inOutIndex); // NTV2QtrSizeExpandMode acVideoQuarterSizeExpand
4178  acVideoQuarterSizeExpand = NTV2QtrSizeExpandMode(v16);
4179  ok &= acHDMIAuxData.RPCDecode(inBlob, inOutIndex); // NTV2Buffer acHDMIAuxData
4180  POPU32(acPeerToPeerFlags, inBlob, inOutIndex); // ULWord acPeerToPeerFlags
4181  POPU32(acFrameRepeatCount, inBlob, inOutIndex); // ULWord acFrameRepeatCount
4182  POPU32(v32, inBlob, inOutIndex); // LWord acDesiredFrame
4183  acDesiredFrame = LWord(v32);
4184  ok &= acRP188.RPCDecode(inBlob, inOutIndex); // NTV2_RP188 acRP188
4185  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint acCrosspoint
4186  acCrosspoint = NTV2Crosspoint(v16);
4187  ok &= acTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER acTrailer
4188  AJADebug::StatTimerStop(AJA_DebugStat_ACXferRPCDecode);
4189  return ok;
4190  }
4191 
4192  bool AUTOCIRCULATE_TRANSFER_STRUCT::RPCEncode (UByteSequence & outBlob)
4193  {
4194  NTV2Buffer buff;
4195  PUSHU16(UWord(channelSpec), outBlob); // NTV2Crosspoint channelSpec
4196 // PUSHU64(ULWord64(videoBuffer), outBlob) // ULWord * videoBuffer
4197  PUSHU32(videoBufferSize, outBlob); // ULWord videoBufferSize
4198  if (videoBuffer && videoBufferSize)
4199  { buff.Set(videoBuffer, videoBufferSize);
4200  buff.AppendU8s(outBlob);
4201  }
4202  PUSHU32(videoDmaOffset, outBlob); // ULWord videoDmaOffset
4203 // PUSHU64(ULWord64(audioBuffer), outBlob) // ULWord * audioBuffer
4204  PUSHU32(audioBufferSize, outBlob); // ULWord audioBufferSize
4205  if (audioBuffer && audioBufferSize)
4206  { buff.Set(audioBuffer, audioBufferSize);
4207  buff.AppendU8s(outBlob);
4208  }
4209  PUSHU32(audioStartSample, outBlob); // ULWord audioStartSample
4210  PUSHU32(audioNumChannels, outBlob); // ULWord audioNumChannels
4211  PUSHU32(frameRepeatCount, outBlob); // ULWord frameRepeatCount
4212  rp188.RPCEncode(outBlob); // RP188_STRUCT rp188
4213  PUSHU32(ULWord(desiredFrame), outBlob); // LWord desiredFrame
4214  PUSHU32(hUser, outBlob); // ULWord hUser
4215  PUSHU32(transferFlags, outBlob); // ULWord transferFlags
4216  PUSHU8(bDisableExtraAudioInfo, outBlob); // BOOL_ bDisableExtraAudioInfo
4217  PUSHU16(UWord(frameBufferFormat), outBlob); // NTV2PixelFormat frameBufferFormat
4218  PUSHU16(UWord(frameBufferOrientation), outBlob); // NTV2FBOrientation frameBufferOrientation
4219  // Skip color correction for now // NTV2ColorCorrectionInfo colorCorrectionInfo
4220  vidProcInfo.RPCEncode(outBlob); // AutoCircVidProcInfo vidProcInfo
4221  PUSHU32(customAncInfo.Group1, outBlob); // CUSTOM_ANC_STRUCT customAncInfo
4222  PUSHU32(customAncInfo.Group2, outBlob);
4223  PUSHU32(customAncInfo.Group3, outBlob);
4224  PUSHU32(customAncInfo.Group4, outBlob);
4225  PUSHU32(videoNumSegments, outBlob); // ULWord videoNumSegments
4226  PUSHU32(videoSegmentHostPitch, outBlob); // ULWord videoSegmentHostPitch
4227  PUSHU32(videoSegmentCardPitch, outBlob); // ULWord videoSegmentCardPitch
4228  PUSHU16(UWord(videoQuarterSizeExpand), outBlob); // NTV2QtrSizeExpandMode videoQuarterSizeExpand
4229  return true;
4230  }
4231 
4232  bool AUTOCIRCULATE_TRANSFER_STRUCT::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4233  { UWord v16(0); ULWord v32(0);
4234  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint channelSpec
4235  channelSpec = NTV2Crosspoint(v16);
4236 // POPU64(u64, inBlob, inOutIndex); // ULWord * videoBuffer
4237 // videoBuffer = reinterpret_cast<ULWord*>(u64);
4238  POPU32(videoBufferSize, inBlob, inOutIndex); // ULWord videoBufferSize
4239  if (videoBufferSize && !videoBuffer)
4240  {
4241  videoBuffer = reinterpret_cast<ULWord*>(AJAMemory::AllocateAligned(videoBufferSize, NTV2Buffer::DefaultPageSize()));
4242  if (!videoBuffer)
4243  return false;
4244  if ((inOutIndex + videoBufferSize) >= inBlob.size())
4245  return false; // past end of inBlob
4246  UByte* pBuffer = reinterpret_cast<UByte*>(videoBuffer);
4247  for (ULWord cnt(0); cnt < videoBufferSize; cnt++)
4248  pBuffer[cnt] = inBlob.at(inOutIndex++); // Caller is responsible for byte-swapping if needed
4249  }
4250  POPU32(videoDmaOffset, inBlob, inOutIndex); // ULWord videoDmaOffset
4251 // POPU64(u64, inBlob, inOutIndex); // ULWord * audioBuffer
4252 // audioBuffer = reinterpret_cast<ULWord*>(u64);
4253  POPU32(audioBufferSize, inBlob, inOutIndex); // ULWord audioBufferSize
4254  if (audioBufferSize && !audioBuffer)
4255  {
4256  audioBuffer = reinterpret_cast<ULWord*>(AJAMemory::AllocateAligned(audioBufferSize, NTV2Buffer::DefaultPageSize()));
4257  if (!audioBuffer)
4258  return false;
4259  if ((inOutIndex + audioBufferSize) >= inBlob.size())
4260  return false; // past end of inBlob
4261  UByte* pBuffer = reinterpret_cast<UByte*>(audioBuffer);
4262  for (ULWord cnt(0); cnt < audioBufferSize; cnt++)
4263  pBuffer[cnt] = inBlob.at(inOutIndex++); // Caller is responsible for byte-swapping if needed
4264  }
4265  POPU32(audioStartSample, inBlob, inOutIndex); // ULWord audioStartSample
4266  POPU32(audioNumChannels, inBlob, inOutIndex); // ULWord audioNumChannels
4267  POPU32(frameRepeatCount, inBlob, inOutIndex); // ULWord frameRepeatCount
4268  rp188.RPCDecode(inBlob, inOutIndex); // RP188_STRUCT rp188
4269  POPU32(v32, inBlob, inOutIndex); // LWord desiredFrame
4270  desiredFrame = LWord(v32);
4271  POPU32(hUser, inBlob, inOutIndex); // ULWord hUser
4272  POPU32(transferFlags, inBlob, inOutIndex); // ULWord transferFlags
4273  POPU8(AsU8Ref(bDisableExtraAudioInfo), inBlob, inOutIndex); // BOOL_ bDisableExtraAudioInfo
4274  POPU16(v16, inBlob, inOutIndex); // NTV2PixelFormat frameBufferFormat
4275  frameBufferFormat = NTV2PixelFormat(v16);
4276  POPU16(v16, inBlob, inOutIndex); // NTV2FBOrientation frameBufferOrientation
4277  frameBufferOrientation = NTV2FBOrientation(v16);
4278  // Skip color correction for now // NTV2ColorCorrectionInfo colorCorrectionInfo
4279  vidProcInfo.RPCDecode(inBlob, inOutIndex); // AutoCircVidProcInfo vidProcInfo
4280  POPU32(customAncInfo.Group1, inBlob, inOutIndex); // CUSTOM_ANC_STRUCT customAncInfo
4281  POPU32(customAncInfo.Group2, inBlob, inOutIndex);
4282  POPU32(customAncInfo.Group3, inBlob, inOutIndex);
4283  POPU32(customAncInfo.Group4, inBlob, inOutIndex);
4284  POPU32(videoNumSegments, inBlob, inOutIndex); // ULWord videoNumSegments
4285  POPU32(videoSegmentHostPitch, inBlob, inOutIndex); // ULWord videoSegmentHostPitch
4286  POPU32(videoSegmentCardPitch, inBlob, inOutIndex); // ULWord videoSegmentCardPitch
4287  POPU16(v16, inBlob, inOutIndex); // NTV2QtrSizeExpandMode videoQuarterSizeExpand
4288  videoQuarterSizeExpand = NTV2QtrSizeExpandMode(v16);
4289  return true;
4290  }
4291 
4292  bool NTV2Bitstream::RPCEncode (UByteSequence & outBlob)
4293  {
4294  const size_t totBytes (mHeader.GetSizeInBytes()); // Header + natural size of all structs/fields inbetween + Trailer
4295  if (outBlob.capacity() < totBytes)
4296  outBlob.reserve(totBytes);
4297  bool ok = mHeader.RPCEncode(outBlob); // NTV2_HEADER mHeader
4298  ok &= mBuffer.RPCEncode(outBlob); // NTV2Buffer mBuffer
4299  PUSHU32(mFlags, outBlob); // ULWord mFlags
4300  PUSHU32(mStatus, outBlob); // ULWord mStatus
4301  for (size_t ndx(0); ndx < 16; ndx++)
4302  PUSHU32(mRegisters[ndx], outBlob); // ULWord mRegisters[16]
4303  for (size_t ndx(0); ndx < 32; ndx++)
4304  PUSHU32(mReserved[ndx], outBlob); // ULWord mReserved[32]
4305  ok &= mTrailer.RPCEncode(outBlob); // NTV2_TRAILER mTrailer
4306  return ok;
4307  }
4308 
4309  bool NTV2Bitstream::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4310  {
4311  bool ok = mHeader.RPCDecode(inBlob, inOutIndex); // NTV2_HEADER acHeader
4312  ok &= mBuffer.RPCDecode(inBlob, inOutIndex); // NTV2Buffer mBuffer
4313  POPU32(mFlags, inBlob, inOutIndex); // ULWord mFlags
4314  POPU32(mStatus, inBlob, inOutIndex); // ULWord mStatus
4315  for (size_t ndx(0); ndx < 16; ndx++)
4316  POPU32(mRegisters[ndx], inBlob, inOutIndex); // ULWord mRegisters[16]
4317  for (size_t ndx(0); ndx < 16; ndx++)
4318  POPU32(mReserved[ndx], inBlob, inOutIndex); // ULWord mReserved[16]
4319  ok &= mTrailer.RPCDecode(inBlob, inOutIndex); // NTV2_TRAILER mTrailer
4320  return ok;
4321  }
4322 
4323  bool AUTOCIRCULATE_STATUS_STRUCT::RPCEncode (UByteSequence & outBlob)
4324  {
4325  PUSHU16(UWord(channelSpec), outBlob); // NTV2Crosspoint channelSpec
4326  PUSHU16(UWord(state), outBlob); // NTV2AutoCirculateState state
4327  PUSHU32(ULWord(startFrame), outBlob); // LWord startFrame
4328  PUSHU32(ULWord(endFrame), outBlob); // LWord endFrame
4329  PUSHU32(ULWord(activeFrame), outBlob); // LWord activeFrame
4330  PUSHU64(rdtscStartTime, outBlob); // ULWord64 rdtscStartTime
4331  PUSHU64(audioClockStartTime, outBlob); // ULWord64 audioClockStartTime
4332  PUSHU64(rdtscCurrentTime, outBlob); // ULWord64 rdtscCurrentTime
4333  PUSHU64(audioClockCurrentTime, outBlob); // ULWord64 audioClockCurrentTime
4334  PUSHU32(framesProcessed, outBlob); // ULWord framesProcessed
4335  PUSHU32(framesDropped, outBlob); // ULWord framesDropped
4336  PUSHU32(bufferLevel, outBlob); // ULWord bufferLevel
4337  PUSHU8(bWithAudio, outBlob); // BOOL_ bWithAudio
4338  PUSHU8(bWithRP188, outBlob); // BOOL_ bWithRP188
4339  PUSHU8(bFbfChange, outBlob); // BOOL_ bFbfChange
4340  PUSHU8(bFboChange, outBlob); // BOOL_ bFboChange
4341  PUSHU8(bWithColorCorrection, outBlob); // BOOL_ bWithColorCorrection
4342  PUSHU8(bWithVidProc, outBlob); // BOOL_ bWithVidProc
4343  PUSHU8(bWithCustomAncData, outBlob); // BOOL_ bWithCustomAncData
4344  return true;
4345  }
4346 
4347  bool AUTOCIRCULATE_STATUS_STRUCT::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4348  { uint16_t v16(0); uint32_t v32(0);
4349  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint channelSpec
4350  channelSpec = NTV2Crosspoint(v16);
4351  POPU16(v16, inBlob, inOutIndex); // NTV2AutoCirculateState state
4352  state = NTV2AutoCirculateState(v16);
4353  POPU32(v32, inBlob, inOutIndex); // LWord startFrame
4354  startFrame = LWord(v32);
4355  POPU32(v32, inBlob, inOutIndex); // LWord endFrame
4356  endFrame = LWord(v32);
4357  POPU32(v32, inBlob, inOutIndex); // LWord activeFrame
4358  activeFrame = LWord(v32);
4359  POPU64(rdtscStartTime, inBlob, inOutIndex); // ULWord64 rdtscStartTime
4360  POPU64(audioClockStartTime, inBlob, inOutIndex); // ULWord64 audioClockStartTime
4361  POPU64(rdtscCurrentTime, inBlob, inOutIndex); // ULWord64 rdtscCurrentTime
4362  POPU64(audioClockCurrentTime, inBlob, inOutIndex); // ULWord64 audioClockCurrentTime
4363  POPU32(framesProcessed, inBlob, inOutIndex); // ULWord framesProcessed
4364  POPU32(framesDropped, inBlob, inOutIndex); // ULWord framesDropped
4365  POPU32(bufferLevel, inBlob, inOutIndex); // ULWord bufferLevel
4366  POPU8(AsU8Ref(bWithAudio), inBlob, inOutIndex); // BOOL_ bWithAudio
4367  POPU8(AsU8Ref(bWithRP188), inBlob, inOutIndex); // BOOL_ bWithRP188
4368  POPU8(AsU8Ref(bFbfChange), inBlob, inOutIndex); // BOOL_ bFbfChange
4369  POPU8(AsU8Ref(bFboChange), inBlob, inOutIndex); // BOOL_ bFboChange
4370  POPU8(AsU8Ref(bWithColorCorrection), inBlob, inOutIndex);// BOOL_ bWithColorCorrection
4371  POPU8(AsU8Ref(bWithVidProc), inBlob, inOutIndex); // BOOL_ bWithVidProc
4372  POPU8(AsU8Ref(bWithCustomAncData), inBlob, inOutIndex); // BOOL_ bWithCustomAncData
4373  return true;
4374  }
4375 
4376  bool RP188_STRUCT::RPCEncode (UByteSequence & outBlob)
4377  {
4378  PUSHU32(DBB, outBlob); // ULWord DBB
4379  PUSHU32(Low, outBlob); // ULWord Low
4380  PUSHU32(High, outBlob); // ULWord High
4381  return true;
4382  }
4383 
4384  bool RP188_STRUCT::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4385  {
4386  POPU32(DBB, inBlob, inOutIndex); // ULWord DBB
4387  POPU32(Low, inBlob, inOutIndex); // ULWord Low
4388  POPU32(High, inBlob, inOutIndex); // ULWord High
4389  return true;
4390  }
4391 
4392 
4393  bool AUTOCIRCULATE_TASK_STRUCT::RPCEncode (UByteSequence & outBlob)
4394  {
4395  PUSHU32(taskVersion, outBlob); // ULWord taskVersion
4396  PUSHU32(taskSize, outBlob); // ULWord taskSize
4397  PUSHU32(numTasks, outBlob); // ULWord numTasks
4398  PUSHU32(maxTasks, outBlob); // ULWord maxTasks
4399  PUSHU64(ULWord64(taskArray), outBlob); // ULWord taskArray
4400  if (taskArray && numTasks)
4401  for (ULWord num(0); num < numTasks; num++)
4402  {
4403  const AutoCircGenericTask & task (taskArray[num]);
4404  PUSHU32(task.taskType, outBlob); // AutoCircTaskType taskType
4405  const ULWord * pULWords = reinterpret_cast<const ULWord*>(&task.u);
4406  ULWord numWords(0);
4407  if (NTV2_IS_REGISTER_TASK(task.taskType))
4408  numWords = sizeof(AutoCircRegisterTask)/sizeof(ULWord);
4409  else if (NTV2_IS_TIMECODE_TASK(task.taskType))
4410  numWords = sizeof(AutoCircTimeCodeTask)/sizeof(ULWord);
4411  for (ULWord word(0); word < numWords; word++)
4412  PUSHU32(pULWords[word], outBlob);
4413  }
4414  return true;
4415  }
4416 
4417  bool AUTOCIRCULATE_TASK_STRUCT::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4418  { ULWord u32(0); ULWord64 u64(0);
4419  POPU32(taskVersion, inBlob, inOutIndex); // ULWord taskVersion
4420  POPU32(taskSize, inBlob, inOutIndex); // ULWord taskSize
4421  POPU32(numTasks, inBlob, inOutIndex); // ULWord numTasks
4422  POPU32(maxTasks, inBlob, inOutIndex); // ULWord maxTasks
4423  POPU64(u64, inBlob, inOutIndex); // ULWord taskArray
4424  taskArray = reinterpret_cast<AutoCircGenericTask*>(u64);
4425  if (taskArray && numTasks)
4426  for (ULWord num(0); num < numTasks; num++)
4427  {
4428  AutoCircGenericTask & task (taskArray[num]);
4429  POPU32(u32, inBlob, inOutIndex); // AutoCircTaskType taskType
4430  task.taskType = AutoCircTaskType(u32);
4431  ULWord * pULWords = reinterpret_cast<ULWord*>(&task.u);
4432  ULWord numWords(0);
4433  if (NTV2_IS_REGISTER_TASK(task.taskType))
4434  numWords = sizeof(AutoCircRegisterTask)/sizeof(ULWord);
4435  else if (NTV2_IS_TIMECODE_TASK(task.taskType))
4436  numWords = sizeof(AutoCircTimeCodeTask)/sizeof(ULWord);
4437  for (ULWord word(0); word < numWords; word++)
4438  POPU32(pULWords[word], inBlob, inOutIndex);
4439  }
4440  return true;
4441  }
4442 
4443  bool FRAME_STAMP_STRUCT::RPCEncode (UByteSequence & outBlob)
4444  {
4445  PUSHU16(UWord(channelSpec), outBlob); // NTV2Crosspoint channelSpec
4446  PUSHU64(ULWord64(frameTime), outBlob); // LWord64 frameTime
4447  PUSHU32(frame, outBlob); // ULWord frame
4448  PUSHU64(audioClockTimeStamp, outBlob); // ULWord64 audioClockTimeStamp
4449  PUSHU32(audioExpectedAddress, outBlob); // ULWord audioExpectedAddress
4450  PUSHU32(audioInStartAddress, outBlob); // ULWord audioInStartAddress
4451  PUSHU32(audioInStopAddress, outBlob); // ULWord audioInStopAddress
4452  PUSHU32(audioOutStopAddress, outBlob); // ULWord audioOutStopAddress
4453  PUSHU32(audioOutStartAddress, outBlob); // ULWord audioOutStartAddress
4454  PUSHU32(bytesRead, outBlob); // ULWord bytesRead
4455  PUSHU32(startSample, outBlob); // ULWord startSample
4456  PUSHU64(ULWord64(currentTime), outBlob); // LWord64 currentTime
4457  PUSHU32(currentFrame, outBlob); // ULWord currentFrame
4458  currentRP188.RPCEncode(outBlob); // RP188_STRUCT currentRP188
4459  PUSHU64(ULWord64(currentFrameTime), outBlob); // LWord64 currentFrameTime
4460  PUSHU64(audioClockCurrentTime, outBlob); // ULWord64 audioClockCurrentTime
4461  PUSHU32(currentAudioExpectedAddress, outBlob); // ULWord currentAudioExpectedAddress
4462  PUSHU32(currentAudioStartAddress, outBlob); // ULWord currentAudioStartAddress
4463  PUSHU32(currentFieldCount, outBlob); // ULWord currentFieldCount
4464  PUSHU32(currentLineCount, outBlob); // ULWord currentLineCount
4465  PUSHU32(currentReps, outBlob); // ULWord currentReps
4466  PUSHU32(currenthUser, outBlob); // ULWord currenthUser
4467  return true;
4468  }
4469 
4470  bool FRAME_STAMP_STRUCT::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4471  { uint16_t v16(0); uint64_t v64(0);
4472  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint channelSpec
4473  channelSpec = NTV2Crosspoint(v16);
4474  POPU64(v64, inBlob, inOutIndex); // LWord64 frameTime
4475  frameTime = LWord64(v64);
4476  POPU32(frame, inBlob, inOutIndex); // ULWord frame
4477  POPU64(audioClockTimeStamp, inBlob, inOutIndex); // ULWord64 audioClockTimeStamp
4478  POPU32(audioExpectedAddress, inBlob, inOutIndex); // ULWord audioExpectedAddress
4479  POPU32(audioInStartAddress, inBlob, inOutIndex); // ULWord audioInStartAddress
4480  POPU32(audioInStopAddress, inBlob, inOutIndex); // ULWord audioInStopAddress
4481  POPU32(audioOutStopAddress, inBlob, inOutIndex); // ULWord audioOutStopAddress
4482  POPU32(audioOutStartAddress, inBlob, inOutIndex); // ULWord audioOutStartAddress
4483  POPU32(bytesRead, inBlob, inOutIndex); // ULWord bytesRead
4484  POPU32(startSample, inBlob, inOutIndex); // ULWord startSample
4485  POPU64(v64, inBlob, inOutIndex); // LWord64 currentTime
4486  currentTime = LWord64(v64);
4487  POPU32(currentFrame, inBlob, inOutIndex); // ULWord currentFrame
4488  currentRP188.RPCDecode(inBlob, inOutIndex); // RP188_STRUCT currentRP188
4489  POPU64(v64, inBlob, inOutIndex); // LWord64 currentFrameTime
4490  currentFrameTime = LWord64(v64);
4491  POPU64(audioClockCurrentTime, inBlob, inOutIndex); // ULWord64 audioClockCurrentTime
4492  POPU32(currentAudioExpectedAddress, inBlob, inOutIndex);// ULWord currentAudioExpectedAddress
4493  POPU32(currentAudioStartAddress, inBlob, inOutIndex); // ULWord currentAudioStartAddress
4494  POPU32(currentFieldCount, inBlob, inOutIndex); // ULWord currentFieldCount
4495  POPU32(currentLineCount, inBlob, inOutIndex); // ULWord currentLineCount
4496  POPU32(currentReps, inBlob, inOutIndex); // ULWord currentReps
4497  POPU32(currenthUser, inBlob, inOutIndex); // ULWord currenthUser
4498  return true;
4499  }
4500 
4501  bool AUTOCIRCULATE_DATA::RPCEncode (UByteSequence & outBlob)
4502  {
4503  PUSHU16(UWord(eCommand), outBlob); // AUTO_CIRC_COMMAND eCommand
4504  PUSHU16(UWord(channelSpec), outBlob); // NTV2Crosspoint channelSpec
4505  PUSHU32(ULWord(lVal1), outBlob); // LWord lVal1
4506  PUSHU32(ULWord(lVal2), outBlob); // LWord lVal2
4507  PUSHU32(ULWord(lVal3), outBlob); // LWord lVal3
4508  PUSHU32(ULWord(lVal4), outBlob); // LWord lVal4
4509  PUSHU32(ULWord(lVal5), outBlob); // LWord lVal5
4510  PUSHU32(ULWord(lVal6), outBlob); // LWord lVal6
4511  PUSHU8(bVal1, outBlob); // BOOL_ bVal1
4512  PUSHU8(bVal2, outBlob); // BOOL_ bVal2
4513  PUSHU8(bVal3, outBlob); // BOOL_ bVal3
4514  PUSHU8(bVal4, outBlob); // BOOL_ bVal4
4515  PUSHU8(bVal5, outBlob); // BOOL_ bVal5
4516  PUSHU8(bVal6, outBlob); // BOOL_ bVal6
4517  PUSHU8(bVal7, outBlob); // BOOL_ bVal7
4518  PUSHU8(bVal8, outBlob); // BOOL_ bVal8
4519  PUSHU64(ULWord64(pvVal1), outBlob); // void* pvVal1
4520  PUSHU64(ULWord64(pvVal2), outBlob); // void* pvVal2
4521  PUSHU64(ULWord64(pvVal3), outBlob); // void* pvVal3
4522  PUSHU64(ULWord64(pvVal4), outBlob); // void* pvVal4
4523  if (eCommand == eGetAutoCirc && pvVal1)
4524  reinterpret_cast<AUTOCIRCULATE_STATUS_STRUCT*>(pvVal1)->RPCEncode(outBlob);
4525  if ((eCommand == eGetFrameStamp || eCommand == eGetFrameStampEx2) && pvVal1)
4526  reinterpret_cast<FRAME_STAMP_STRUCT*>(pvVal1)->RPCEncode(outBlob);
4527  if (eCommand == eGetFrameStampEx2 && pvVal2)
4528  reinterpret_cast<AUTOCIRCULATE_TASK_STRUCT*>(pvVal2)->RPCEncode(outBlob);
4529  if (eCommand == eTransferAutoCirculate && pvVal1)
4530  reinterpret_cast<AUTOCIRCULATE_TRANSFER_STRUCT*>(pvVal1)->RPCEncode(outBlob);
4531  return true;
4532  }
4533 
4534  bool AUTOCIRCULATE_DATA::RPCDecode (const UByteSequence & inBlob, size_t & inOutIndex)
4535  {
4536 #if defined(AJA_LINUX)
4537  #pragma GCC diagnostic push
4538  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
4539 #endif
4540  uint16_t v16(0); uint32_t v32(0);
4541  POPU16(v16, inBlob, inOutIndex); // AUTO_CIRC_COMMAND eCommand
4542  eCommand = AUTO_CIRC_COMMAND(v16);
4543  POPU16(v16, inBlob, inOutIndex); // NTV2Crosspoint channelSpec
4544  channelSpec = NTV2Crosspoint(v16);
4545  POPU32(v32, inBlob, inOutIndex); lVal1 = LWord(v32); // LWord lVal1
4546  POPU32(v32, inBlob, inOutIndex); lVal2 = LWord(v32); // LWord lVal2
4547  POPU32(v32, inBlob, inOutIndex); lVal3 = LWord(v32); // LWord lVal3
4548  POPU32(v32, inBlob, inOutIndex); lVal4 = LWord(v32); // LWord lVal4
4549  POPU32(v32, inBlob, inOutIndex); lVal5 = LWord(v32); // LWord lVal5
4550  POPU32(v32, inBlob, inOutIndex); lVal6 = LWord(v32); // LWord lVal6
4551  POPU8(AsU8Ref(bVal1), inBlob, inOutIndex); // BOOL_ bVal1
4552  POPU8(AsU8Ref(bVal2), inBlob, inOutIndex); // BOOL_ bVal2
4553  POPU8(AsU8Ref(bVal3), inBlob, inOutIndex); // BOOL_ bVal3
4554  POPU8(AsU8Ref(bVal4), inBlob, inOutIndex); // BOOL_ bVal4
4555  POPU8(AsU8Ref(bVal5), inBlob, inOutIndex); // BOOL_ bVal5
4556  POPU8(AsU8Ref(bVal6), inBlob, inOutIndex); // BOOL_ bVal6
4557  POPU8(AsU8Ref(bVal7), inBlob, inOutIndex); // BOOL_ bVal7
4558  POPU8(AsU8Ref(bVal8), inBlob, inOutIndex); // BOOL_ bVal8
4559  POPU64(AsU64Ref(pvVal1), inBlob, inOutIndex); // void* pvVal1
4560  POPU64(AsU64Ref(pvVal2), inBlob, inOutIndex); // void* pvVal2
4561  POPU64(AsU64Ref(pvVal3), inBlob, inOutIndex); // void* pvVal3
4562  POPU64(AsU64Ref(pvVal4), inBlob, inOutIndex); // void* pvVal4
4563 #if defined(AJA_LINUX)
4564  #pragma GCC diagnostic pop
4565 #endif
4566  if (eCommand == eGetAutoCirc && pvVal1)
4567  reinterpret_cast<AUTOCIRCULATE_STATUS_STRUCT*>(pvVal1)->RPCDecode(inBlob, inOutIndex);
4568  if ((eCommand == eGetFrameStamp || eCommand == eGetFrameStampEx2) && pvVal1)
4569  reinterpret_cast<FRAME_STAMP_STRUCT*>(pvVal1)->RPCDecode(inBlob, inOutIndex);
4570  if (eCommand == eGetFrameStampEx2 && pvVal2)
4571  reinterpret_cast<AUTOCIRCULATE_TASK_STRUCT*>(pvVal2)->RPCDecode(inBlob, inOutIndex);
4572  if (eCommand == eTransferAutoCirculate && pvVal1)
4573  reinterpret_cast<AUTOCIRCULATE_TRANSFER_STRUCT*>(pvVal1)->RPCDecode(inBlob, inOutIndex);
4574  return true;
4575  }
NTV2InputSourceSet
std::set< NTV2InputSource > NTV2InputSourceSet
A set of distinct NTV2InputSource values.
Definition: ntv2publicinterface.h:9022
ntv2nub::POPU32
void POPU32(uint32_t &outVal, const std::vector< uint8_t > &inArr, std::size_t &inOutNdx, const bool dontSwap=false)
Definition: ntv2nubtypes.h:69
NTV2BankSelGetSetRegs::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:7783
NTV2SegmentedDMAInfo::acSegmentHostPitch
ULWord acSegmentHostPitch
Offset, in bytes, between the start of one host segment and the start of the next host segment (i....
Definition: ntv2publicinterface.h:7211
kRegLPRJ45IP
@ kRegLPRJ45IP
Definition: ntv2publicinterface.h:1089
NTV2GetRegisters::GetGoodRegisters
bool GetGoodRegisters(NTV2RegNumSet &outGoodRegNums) const
Returns an NTV2RegNumSet built from my mOutGoodRegisters field.
Definition: ntv2publicinterface.cpp:3184
AUTOCIRCULATE_TRANSFER::acFrameBufferFormat
NTV2FrameBufferFormat acFrameBufferFormat
Specifies the frame buffer format to change to. Ignored if AUTOCIRCULATE_WITH_FBFCHANGE option is not...
Definition: ntv2publicinterface.h:8279
NTV2GetRegisters::NTV2GetRegisters
NTV2GetRegisters(const NTV2RegNumSet &inRegisterNumbers=NTV2RegNumSet())
Constructs an NTV2GetRegisters struct from the given set of register numbers.
Definition: ntv2publicinterface.cpp:3124
AUTOCIRCULATE_STATUS_STRUCT::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4347
NTV2SegmentedDMAInfo::acNumActiveBytesPerRow
ULWord acNumActiveBytesPerRow
Number of active bytes in a row of video.
Definition: ntv2publicinterface.h:7210
NTV2_AUDIOSYSTEM_Plus3
@ NTV2_AUDIOSYSTEM_Plus3
Definition: ntv2enums.h:3880
FRAME_STAMP_STRUCT::currentAudioStartAddress
ULWord currentAudioStartAddress
As found by isr.
Definition: ntv2publicinterface.h:4614
aja::stoul
unsigned long stoul(const std::string &str, std::size_t *idx, int base)
Definition: common.cpp:143
print_address_offset
static string print_address_offset(const size_t inRadix, const ULWord64 inOffset)
Definition: ntv2publicinterface.cpp:427
ULWordSequenceConstIter
ULWordSequence::const_iterator ULWordSequenceConstIter
A handy const iterator for iterating over a ULWordSequence.
Definition: ntv2publicinterface.h:47
FRAME_STAMP::acRP188
NTV2_RP188 acRP188
Deprecated – call FRAME_STAMP::GetInputTimeCode instead.
Definition: ntv2publicinterface.h:8011
NTV2SegmentedDMAInfo::NTV2SegmentedDMAInfo
NTV2SegmentedDMAInfo()
Constructs a disabled NTV2SegmentedDMAInfo struct.
Definition: ntv2publicinterface.cpp:2712
NTV2SDIInputStatus::Clear
void Clear(void)
Constructs a default NTV2SDIInputStatus.
Definition: ntv2publicinterface.cpp:119
AutoCircRegisterTask
Definition: ntv2publicinterface.h:4802
NTV2ChannelSetToStr
string NTV2ChannelSetToStr(const NTV2ChannelSet &inObj, const bool inCompact)
Definition: ntv2publicinterface.cpp:3517
NTV2Buffer::GetU8s
bool GetU8s(UByteSequence &outU8s, const size_t inU8Offset=0, const size_t inMaxSize=128) const
Answers with my contents as a vector of unsigned 8-bit values.
Definition: ntv2publicinterface.cpp:678
NTV2_AUDIOSYSTEM_Plus1
@ NTV2_AUDIOSYSTEM_Plus1
Definition: ntv2enums.h:3878
NTV2RegisterWritesConstIter
NTV2RegWrites::const_iterator NTV2RegisterWritesConstIter
Definition: ntv2publicinterface.h:4070
NTV2SegmentedXferInfo::reset
NTV2SegmentedXferInfo & reset(void)
Resets me to an invalid (all zero) state.
Definition: ntv2publicinterface.cpp:1609
NTV2DoubleArray
std::vector< double > NTV2DoubleArray
An array of double-precision floating-point values.
Definition: ntv2publicinterface.h:70
LWord
int32_t LWord
Definition: ajatypes.h:254
NTV2Buffer::SetDefaultPageSize
static bool SetDefaultPageSize(const size_t inNewSize)
Changes the default page size for use in future page-aligned allocations.
Definition: ntv2publicinterface.cpp:2155
GetRegisterNumbers
NTV2RegNumSet GetRegisterNumbers(const NTV2RegReads &inRegInfos)
Definition: ntv2publicinterface.cpp:3587
FRAME_STAMP::acTrailer
NTV2_TRAILER acTrailer
The common message trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8013
AUTOCIRCULATE_STATUS::acFramesProcessed
ULWord acFramesProcessed
Total number of frames successfully processed since CNTV2Card::AutoCirculateStart called.
Definition: ntv2publicinterface.h:7332
AJADebug::StatTimerStop
static AJAStatus StatTimerStop(const uint32_t inKey)
Definition: debug.cpp:1155
CNTV2RegisterExpert::IsReadOnly
static bool IsReadOnly(const uint32_t inRegNum)
Definition: ntv2registerexpert.h:116
AUTOCIRCULATE_DATA::channelSpec
NTV2Crosspoint channelSpec
Definition: ntv2publicinterface.h:4477
NTV2SegmentedDMAInfo::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4053
NTV2SDIInStatistics::Clear
void Clear(void)
Resets the struct to its initialized state.
Definition: ntv2publicinterface.cpp:2467
NTV2Bitstream::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4292
NTV2RegNumSetConstIter
ULWordSetConstIter NTV2RegNumSetConstIter
A const iterator that iterates over a set of distinct NTV2RegisterNumbers.
Definition: ntv2publicinterface.h:7578
NTV2RegisterValueMap
std::map< ULWord, ULWord > NTV2RegisterValueMap
A mapping of distinct NTV2RegisterNumbers to their corresponding ULWord values.
Definition: ntv2publicinterface.h:7595
NTV2_IOKINDS_HDMI
@ NTV2_IOKINDS_HDMI
Specifies HDMI input/output kinds.
Definition: ntv2enums.h:1284
NTV2_NUM_STANDARDS
@ NTV2_NUM_STANDARDS
Definition: ntv2enums.h:174
AUTOCIRCULATE_STATUS::WithFBOChange
bool WithFBOChange(void) const
Definition: ntv2publicinterface.h:7516
NTV2GetRegisters::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3783
FRAME_STAMP::acCurrentTime
LWord64 acCurrentTime
The absolute timestamp at the moment the CNTV2Card::AutoCirculateTransfer or CNTV2Card::AutoCirculate...
Definition: ntv2publicinterface.h:7984
kVRegShiftHDMOutVideoFrameRate
@ kVRegShiftHDMOutVideoFrameRate
Definition: ntv2virtualregisters.h:664
AUTOCIRCULATE_TRANSFER::acFrameRepeatCount
ULWord acFrameRepeatCount
Intended for playout. The number of times to repeat the frame being transferred.
Definition: ntv2publicinterface.h:8291
NTV2_TRAILER::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3717
NTV2SegmentedDMAInfo
This struct is used to augment the default full-frame AutoCirculate DMA transfer to accommodate multi...
Definition: ntv2publicinterface.h:7207
AUTOCIRCULATE_STATUS_STRUCT::bFboChange
BOOL_ bFboChange
Definition: ntv2publicinterface.h:4435
NTV2_OUTPUTDESTINATION_HDMI1
@ NTV2_OUTPUTDESTINATION_HDMI1
Definition: ntv2enums.h:1313
NTV2FrameGeometryToString
std::string NTV2FrameGeometryToString(const NTV2FrameGeometry inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:7202
NTV2ChannelListToStr
string NTV2ChannelListToStr(const NTV2ChannelList &inObj, const bool inCompact)
Definition: ntv2publicinterface.cpp:3496
NTV2_IS_VALID_NTV2FrameGeometry
#define NTV2_IS_VALID_NTV2FrameGeometry(__s__)
Definition: ntv2enums.h:371
FRAME_STAMP::acCurrentFrame
ULWord acCurrentFrame
Last vertical blank frame for this autocirculate channel (when CNTV2Card::AutoCirculateGetFrameStamp ...
Definition: ntv2publicinterface.h:7989
AUTOCIRCULATE_TRANSFER_STRUCT::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4192
kRegBoardID
@ kRegBoardID
Definition: ntv2publicinterface.h:153
NTV2StreamChannel
Definition: ntv2publicinterface.h:8908
NTV2HDMIBitDepth
NTV2HDMIBitDepth
Indicates or specifies the HDMI video bit depth.
Definition: ntv2enums.h:3662
NTV2_COLORCORRECTOR_TABLESIZE
#define NTV2_COLORCORRECTOR_TABLESIZE
Definition: ntv2publicinterface.h:4193
FRAME_STAMP::GetInputTimeCode
bool GetInputTimeCode(NTV2_RP188 &outTimeCode, const NTV2TCIndex inTCIndex=NTV2_TCINDEX_SDI1) const
Answers with a specific timecode captured in my acTimeCodes member.
Definition: ntv2publicinterface.cpp:2257
NTV2Buffer::GetU32s
bool GetU32s(ULWordSequence &outU32s, const size_t inU32Offset=0, const size_t inMaxSize=32, const bool inByteSwap=false) const
Answers with my contents as a vector of unsigned 32-bit values.
Definition: ntv2publicinterface.cpp:604
AUTOCIRCULATE_STATUS::acCrosspoint
NTV2Crosspoint acCrosspoint
The crosspoint (channel number with direction)
Definition: ntv2publicinterface.h:7323
AUTOCIRCULATE_STATUS_STRUCT::activeFrame
LWord activeFrame
Definition: ntv2publicinterface.h:4424
AUTOCIRCULATE_WITH_FIELDS
#define AUTOCIRCULATE_WITH_FIELDS
Use this to AutoCirculate with fields as frames for interlaced formats.
Definition: ntv2publicinterface.h:5636
kVRegShiftHDMOutAudioFormat
@ kVRegShiftHDMOutAudioFormat
Definition: ntv2virtualregisters.h:670
NTV2BufferLock::mBuffer
NTV2Buffer mBuffer
Virtual address of a buffer to prelock, and its length.
Definition: ntv2publicinterface.h:8683
AUTOCIRCULATE_DATA::bVal2
BOOL_ bVal2
Definition: ntv2publicinterface.h:4487
RP188_STRUCT::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4384
NTV2PixelFormats
NTV2FrameBufferFormatSet NTV2PixelFormats
Definition: ntv2publicinterface.h:9013
NTV2_MAX_NUM_AudioSystemEnums
@ NTV2_MAX_NUM_AudioSystemEnums
Definition: ntv2enums.h:3875
NTV2_FG_1920x1114
@ NTV2_FG_1920x1114
1920x1080, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:346
NTV2OutputDestinations
std::set< NTV2OutputDestination > NTV2OutputDestinations
A set of distinct NTV2OutputDestination values.
Definition: ntv2publicinterface.h:9025
FRAME_STAMP_STRUCT::currentTime
LWord64 currentTime
Current processor time ... on Windows, this is derived from KeQueryPerformanceCounter.
Definition: ntv2publicinterface.h:4596
ntv2devicefeatures.h
Declares device capability functions.
NTV2_FG_720x576
@ NTV2_FG_720x576
720x576, for PAL 625i, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:345
NTV2_FG_720x508
@ NTV2_FG_720x508
720x486, for NTSC 525i, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:348
AUTOCIRCULATE_STATUS::WithVidProc
bool WithVidProc(void) const
Definition: ntv2publicinterface.h:7526
kVRegShiftHDMOutAudioRate
@ kVRegShiftHDMOutAudioRate
Definition: ntv2virtualregisters.h:671
NTV2ColorCorrectionData::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4069
NTV2Bitstream::SetFlags
void SetFlags(const ULWord inFlags)
Sets the action flags for use in a subsequent call to CNTV2Card::LoadBitstream.
Definition: ntv2publicinterface.h:8841
AJA_NTV2_SDK_VERSION_POINT
#define AJA_NTV2_SDK_VERSION_POINT
The SDK "point" release version, an unsigned decimal integer.
Definition: ntv2version.h:15
FRAME_STAMP::acCurrentUserCookie
ULWord64 acCurrentUserCookie
The frame's AUTOCIRCULATE_TRANSFER::acInUserCookie value that was set when CNTV2Card::AutoCirculateTr...
Definition: ntv2publicinterface.h:8006
AutoCircVidProcMode
AutoCircVidProcMode
Definition: ntv2publicinterface.h:4298
NTV2TCIndexes
std::set< NTV2TCIndex > NTV2TCIndexes
Definition: ntv2publicinterface.h:7007
NTV2RegInfo::setValue
NTV2RegInfo & setValue(const ULWord val)
Definition: ntv2publicinterface.h:4060
NTV2SegmentedXferInfo::swapSourceAndDestination
NTV2SegmentedXferInfo & swapSourceAndDestination(void)
Swaps my source and destination offsets, pitches and scan directions.
Definition: ntv2publicinterface.cpp:1622
AUTOCIRCULATE_TRANSFER::SetAudioBuffer
bool SetAudioBuffer(ULWord *pInAudioBuffer, const ULWord inAudioByteCount)
Sets my audio buffer for use in a subsequent call to CNTV2Card::AutoCirculateTransfer.
Definition: ntv2publicinterface.cpp:2859
NTV2TimeCodeListConstIter
NTV2TimeCodeList::const_iterator NTV2TimeCodeListConstIter
A handy const interator for iterating over an NTV2TimeCodeList.
Definition: ntv2publicinterface.h:7002
NTV2AudioChannelPairs
std::set< NTV2AudioChannelPair > NTV2AudioChannelPairs
A set of distinct NTV2AudioChannelPair values.
Definition: ntv2publicinterface.h:58
NTV2GetSupportedDevices
NTV2DeviceIDSet NTV2GetSupportedDevices(const NTV2DeviceKinds inKinds=NTV2_DEVICEKIND_ALL)
Returns an NTV2DeviceIDSet of devices supported by the SDK.
Definition: ntv2utils.cpp:7598
NTV2DeviceGetSupportedOutputDests
bool NTV2DeviceGetSupportedOutputDests(const NTV2DeviceID inDeviceID, NTV2OutputDestinations &outOutputDests, const NTV2IOKinds inKinds)
Returns a set of distinct NTV2OutputDest values supported on the given device.
Definition: ntv2publicinterface.cpp:1370
GetNTV2FrameGeometryFromVideoFormat
NTV2FrameGeometry GetNTV2FrameGeometryFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:2548
aja::is_hex_digit
bool is_hex_digit(const char inChr)
Definition: common.cpp:511
NTV2_TYPE_ACSTATUS
#define NTV2_TYPE_ACSTATUS
Identifies AUTOCIRCULATE_STATUS struct.
Definition: ntv2publicinterface.h:5572
NTV2AudioFormat
NTV2AudioFormat
Definition: ntv2enums.h:1937
NTV2_TYPE_BANKGETSET
#define NTV2_TYPE_BANKGETSET
Identifies NTV2BankSelGetSetRegs struct.
Definition: ntv2publicinterface.h:5570
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They're also commonly use...
Definition: ntv2enums.h:1343
NTV2HDMIColorSpace
NTV2HDMIColorSpace
Indicates or specifies HDMI Color Space.
Definition: ntv2enums.h:3575
NTV2AudioFormatToString
std::string NTV2AudioFormatToString(const NTV2AudioFormat inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6754
FRAME_STAMP_STRUCT::bytesRead
ULWord bytesRead
Total audio and video bytes transfered.
Definition: ntv2publicinterface.h:4576
NTV2Buffer
Describes a user-space buffer on the host computer. I have an address and a length,...
Definition: ntv2publicinterface.h:6141
AUTOCIRCULATE_STATUS::acStartFrame
LWord acStartFrame
First frame to circulate. FIXFIXFIX Why is this signed? CHANGE TO ULWord??
Definition: ntv2publicinterface.h:7325
NTV2Buffer::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3741
NTV2SetRegisters::NTV2SetRegisters
NTV2SetRegisters(const NTV2RegWrites &inRegWrites=NTV2RegWrites())
Constructs an NTV2SetRegisters struct from the given NTV2RegisterWrites collection.
Definition: ntv2publicinterface.cpp:3325
NTV2PixelFormatsConstIter
NTV2FrameBufferFormatSetConstIter NTV2PixelFormatsConstIter
Definition: ntv2publicinterface.h:9014
NTV2_TYPE_ACXFER
#define NTV2_TYPE_ACXFER
Identifies AUTOCIRCULATE_TRANSFER struct.
Definition: ntv2publicinterface.h:5573
NTV2PrintChannelSet
ostream & NTV2PrintChannelSet(const NTV2ChannelSet &inObj, const bool inCompact, ostream &inOutStream)
Definition: ntv2publicinterface.cpp:3502
NTV2CROSSPOINT_CHANNEL1
@ NTV2CROSSPOINT_CHANNEL1
Definition: ntv2enums.h:1688
NTV2VirtualData::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3674
AJADebug::StatTimerStart
static AJAStatus StatTimerStart(const uint32_t inKey)
Definition: debug.cpp:1135
NTV2Buffer::GetByteCount
ULWord GetByteCount(void) const
Definition: ntv2publicinterface.h:6215
NTV2_STANDARD_INVALID
@ NTV2_STANDARD_INVALID
Definition: ntv2enums.h:176
AUTOCIRCULATE_STATUS::acOptionFlags
ULWord acOptionFlags
AutoCirculate options used when CNTV2Card::AutoCirculateInitForInput or CNTV2Card::AutoCirculateInitF...
Definition: ntv2publicinterface.h:7335
NTV2_ASSERT
#define NTV2_ASSERT(_expr_)
Definition: ajatypes.h:508
NTV2VideoFormatSet
std::set< NTV2VideoFormat > NTV2VideoFormatSet
A set of distinct NTV2VideoFormat values.
Definition: ntv2publicinterface.h:9008
NTV2_STANDARD_1080
@ NTV2_STANDARD_1080
Identifies SMPTE HD 1080i or 1080psf.
Definition: ntv2enums.h:158
kVRegMaskHDMOutColorRGB
@ kVRegMaskHDMOutColorRGB
Definition: ntv2virtualregisters.h:647
GetNTV2FrameRateFromVideoFormat
NTV2FrameRate GetNTV2FrameRateFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:3534
NTV2TimecodeIndex
enum NTV2TCIndex NTV2TimecodeIndex
NTV2Buffer::AppendU8s
bool AppendU8s(UByteSequence &outU8s) const
Appends my contents to an existing UByteSequence.
Definition: ntv2publicinterface.cpp:711
AUTOCIRCULATE_TRANSFER_STATUS::acTransferFrame
LWord acTransferFrame
Frame buffer number the frame was transferred to/from. (-1 if failed)
Definition: ntv2publicinterface.h:8122
NTV2SetRegisters::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:7720
NTV2ColorCorrectionData::ccSaturationValue
ULWord ccSaturationValue
My saturation value, used only in 3-way color correction mode.
Definition: ntv2publicinterface.h:7267
NTV2StandardSet
std::set< NTV2Standard > NTV2StandardSet
A set of distinct NTV2Standard values.
Definition: ntv2publicinterface.h:9019
AUTOCIRCULATE_STATUS::operator[]
std::string operator[](const unsigned inIndexNum) const
Definition: ntv2publicinterface.cpp:2649
AUTOCIRCULATE_TRANSFER::DisableSegmentedDMAs
bool DisableSegmentedDMAs(void)
Disables segmented DMAs, performing a Reset on my acInSegmentedDMAInfo.
Definition: ntv2publicinterface.cpp:2962
NTV2_HEADER::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3704
NTV2ColorCorrectionData::Set
bool Set(const NTV2ColorCorrectionMode inMode, const ULWord inSaturation, const void *pInTableData)
Sets this struct from the given mode, saturation and table data, replacing any existing mode,...
Definition: ntv2publicinterface.cpp:2765
UByteSequence
std::vector< uint8_t > UByteSequence
An ordered sequence of UByte (uint8_t) values.
Definition: ntv2publicinterface.h:38
NTV2DeviceCanDoOutputDestination
bool NTV2DeviceCanDoOutputDestination(const NTV2DeviceID id, const NTV2OutputDest od)
Definition: ntv2devicefeatures.cpp:137
NTV2_FG_2048x1080
@ NTV2_FG_2048x1080
2048x1080, for 2Kx1080p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:352
AUTOCIRCULATE_STATUS_STRUCT::bWithColorCorrection
BOOL_ bWithColorCorrection
Definition: ntv2publicinterface.h:4436
AUTOCIRCULATE_TRANSFER_STATUS::acAncField2TransferSize
ULWord acAncField2TransferSize
Total ancillary data bytes for field 2 transferred (capture only).
Definition: ntv2publicinterface.h:8130
NTV2SetRegisters::mOutBadRegIndexes
NTV2Buffer mOutBadRegIndexes
Array of UWords containing index numbers of the register writes that failed. The SDK owns this memory...
Definition: ntv2publicinterface.h:7724
NTV2StandardSetConstIter
NTV2StandardSet::const_iterator NTV2StandardSetConstIter
A handy const iterator for iterating over an NTV2StandardSet.
Definition: ntv2publicinterface.h:9020
NTV2GeometrySetConstIter
NTV2GeometrySet::const_iterator NTV2GeometrySetConstIter
A handy const iterator for iterating over an NTV2GeometrySet.
Definition: ntv2publicinterface.h:9017
NTV2_FG_INVALID
@ NTV2_FG_INVALID
Definition: ntv2enums.h:368
AUTOCIRCULATE_TRANSFER::EnableSegmentedDMAs
bool EnableSegmentedDMAs(const ULWord inNumSegments, const ULWord inNumActiveBytesPerLine, const ULWord inHostBytesPerLine, const ULWord inDeviceBytesPerLine)
Enables segmented DMAs given a segment count, a host pitch, and device pitch value.
Definition: ntv2publicinterface.cpp:2950
NTV2Buffer::Deallocate
bool Deallocate(void)
Deallocates my user-space storage (if I own it – i.e. from a prior call to Allocate).
Definition: ntv2publicinterface.cpp:1803
NTV2SetRegisters::GetFailedRegisterWrites
bool GetFailedRegisterWrites(NTV2RegWrites &outFailedRegWrites) const
Returns an NTV2RegisterWrites built from my mOutBadRegInfos field.
Definition: ntv2publicinterface.cpp:3361
NTV2_OUTPUTDESTINATION_SDI2
@ NTV2_OUTPUTDESTINATION_SDI2
Definition: ntv2enums.h:1315
NTV2StreamBuffer::NTV2StreamBuffer
NTV2StreamBuffer()
Constructs a default NTV2StreamBuffer struct.
Definition: ntv2publicinterface.cpp:3111
NTV2BufferLock::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3055
NTV2_IS_VALID_TRAILER_TAG
#define NTV2_IS_VALID_TRAILER_TAG(_x_)
Definition: ntv2publicinterface.h:5567
NTV2_OUTPUTDESTINATION_SDI3
@ NTV2_OUTPUTDESTINATION_SDI3
Definition: ntv2enums.h:1316
AUTOCIRCULATE_STATUS::GetProcessedFrameCount
ULWord GetProcessedFrameCount(void) const
Definition: ntv2publicinterface.h:7377
NTV2_HEADER_TAG
#define NTV2_HEADER_TAG
Identifies the struct header.
Definition: ntv2publicinterface.h:5563
NTV2_IS_VALID_TIMECODE_INDEX
#define NTV2_IS_VALID_TIMECODE_INDEX(__x__)
Definition: ntv2enums.h:3954
NTV2FrameSize::FGSizesMapCI
FGSizesMap::const_iterator FGSizesMapCI
Definition: ntv2publicinterface.h:5819
FRAME_STAMP_STRUCT::currentFrame
ULWord currentFrame
Last vertical blank frame for this channel's auto-circulate. (at the time of the IOCTL_NTV2_GET_FRAME...
Definition: ntv2publicinterface.h:4597
ntv2endian.h
Defines a number of handy byte-swapping macros.
NTV2HDMIAudioChannels
NTV2HDMIAudioChannels
Indicates or specifies the HDMI audio channel count.
Definition: ntv2enums.h:3637
NTV2OutputDestinationsConstIter
NTV2OutputDestinations::const_iterator NTV2OutputDestinationsConstIter
A handy const iterator for iterating over an NTV2OutputDestinations.
Definition: ntv2publicinterface.h:9026
NTV2_HEADER::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3691
AUTOCIRCULATE_TRANSFER::acAudioBuffer
NTV2Buffer acAudioBuffer
The host audio buffer. This field is owned by the client application, and thus is responsible for all...
Definition: ntv2publicinterface.h:8223
eStartAutoCircAtTime
@ eStartAutoCircAtTime
Definition: ntv2publicinterface.h:4359
NTV2_TYPE_VIRTUAL_DATA_RW
#define NTV2_TYPE_VIRTUAL_DATA_RW
Identifies NTV2VirtualData struct.
Definition: ntv2publicinterface.h:5569
NTV2GetRegisters::GetBadRegisters
bool GetBadRegisters(NTV2RegNumSet &outBadRegNums) const
Returns the set of register numbers that were not read successfully.
Definition: ntv2publicinterface.cpp:3201
NTV2BufferLock::SetBuffer
bool SetBuffer(const NTV2Buffer &inBuffer)
Sets the buffer to lock for use in a subsequent call to CNTV2Card::DMABufferLock.
Definition: ntv2publicinterface.cpp:3049
NTV2DebugLogging::NTV2DebugLogging
NTV2DebugLogging(const bool inEnable=false)
Constructs an NTV2DebugLogging struct.
Definition: ntv2publicinterface.cpp:2998
NTV2_RP188::Set
void Set(const ULWord inDBB=0xFFFFFFFF, const ULWord inLow=0xFFFFFFFF, const ULWord inHigh=0xFFFFFFFF)
Sets my fields from the given DBB, low and high ULWord components.
Definition: ntv2publicinterface.h:6981
AUTOCIRCULATE_DATA::bVal3
BOOL_ bVal3
Definition: ntv2publicinterface.h:4488
NTV2SetRegisters::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3827
FRAME_STAMP_STRUCT::audioExpectedAddress
ULWord audioExpectedAddress
The address that was used to transfer.
Definition: ntv2publicinterface.h:4561
NTV2Buffer::SetFrom
bool SetFrom(const NTV2Buffer &inBuffer)
Replaces my contents from the given memory buffer without resizing me.
Definition: ntv2publicinterface.cpp:1840
AUTOCIRCULATE_STATUS::GetBufferLevel
ULWord GetBufferLevel(void) const
Definition: ntv2publicinterface.h:7382
AUTOCIRCULATE_TRANSFER::GetInputTimeCode
bool GetInputTimeCode(NTV2_RP188 &outTimeCode, const NTV2TCIndex inTCIndex=NTV2_TCINDEX_SDI1) const
Intended for capture, answers with a specific timecode captured in my acTransferStatus member's acFra...
Definition: ntv2publicinterface.cpp:2984
kVRegShiftHDMOutBitDepth
@ kVRegShiftHDMOutBitDepth
Definition: ntv2virtualregisters.h:665
NTV2PrintChannelList
ostream & NTV2PrintChannelList(const NTV2ChannelList &inObj, const bool inCompact, ostream &inOutStream)
Definition: ntv2publicinterface.cpp:3481
NTV2DeviceID
NTV2DeviceID
Identifies a specific AJA NTV2 device model number. The NTV2DeviceID is actually the PROM part number...
Definition: ntv2enums.h:20
NTV2BankSelGetSetRegs::NTV2BankSelGetSetRegs
NTV2BankSelGetSetRegs(const NTV2RegInfo &inBankSelect, const NTV2RegInfo &inRegInfo, const bool inDoWrite=false)
Constructs an NTV2BankSelGetSetRegs struct for atomically reading or writing the given bank-selected ...
Definition: ntv2publicinterface.cpp:3620
FRAME_STAMP_STRUCT::audioOutStartAddress
ULWord audioOutStartAddress
For play - end position (exclusive) in buffer of audio.
Definition: ntv2publicinterface.h:4573
DEC0N
#define DEC0N(__x__, __n__)
Definition: ntv2publicinterface.h:5696
ThousandsSeparator::do_grouping
virtual std::string do_grouping() const
Definition: ntv2publicinterface.cpp:2635
NTV2RegisterNumberToString
std::string NTV2RegisterNumberToString(const NTV2RegisterNumber inValue)
Definition: ntv2utils.cpp:7757
AJADebug
Definition: debug.h:243
NTV2GetRegisters::GetRequestedRegisterNumbers
bool GetRequestedRegisterNumbers(NTV2RegNumSet &outRegNums) const
Answers with the set of register numbers that were requested.
Definition: ntv2publicinterface.cpp:3166
AUTOCIRCULATE_TRANSFER::SetFrameBufferFormat
bool SetFrameBufferFormat(const NTV2FrameBufferFormat inNewFormat)
Sets my acFrameBufferFormat value to the given new value (if valid and circulating with AUTOCIRCULATE...
Definition: ntv2publicinterface.cpp:2933
kVRegMaskHDMOutVideoStandard
@ kVRegMaskHDMOutVideoStandard
Definition: ntv2virtualregisters.h:644
FRAME_STAMP::acAudioOutStopAddress
ULWord acAudioOutStopAddress
(output/playback only) Audio play head position when this frame was stamped.
Definition: ntv2publicinterface.h:7955
NTV2FrameBufferFormat
NTV2FrameBufferFormat
Identifies a particular video frame buffer format. See Device Frame Buffer Formats for details.
Definition: ntv2enums.h:210
AUTOCIRCULATE_STATUS::WithHDMIAuxData
bool WithHDMIAuxData(void) const
Definition: ntv2publicinterface.h:7536
AutoCircGenericTask::taskType
AutoCircTaskType taskType
Definition: ntv2publicinterface.h:4834
NTV2_FG_720x486
@ NTV2_FG_720x486
720x486, for NTSC 525i and 525p60, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:344
NTV2_IS_ATC_VITC2_TIMECODE_INDEX
#define NTV2_IS_ATC_VITC2_TIMECODE_INDEX(__x__)
Definition: ntv2enums.h:3961
NTV2Buffer::Allocate
bool Allocate(const size_t inByteCount, const bool inPageAligned=false)
Allocates (or re-allocates) my user-space storage using the given byte count. I assume full responsib...
Definition: ntv2publicinterface.cpp:1769
NTV2ColorCorrectionModeToString
std::string NTV2ColorCorrectionModeToString(const NTV2ColorCorrectionMode inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:7777
NTV2DeviceGetSupportedPixelFormats
bool NTV2DeviceGetSupportedPixelFormats(const NTV2DeviceID inDeviceID, NTV2PixelFormats &outFormats)
Returns a set of distinct NTV2FrameBufferFormat values supported on the given device.
Definition: ntv2publicinterface.cpp:1299
NTV2Buffer::NTV2Buffer
NTV2Buffer(const void *pInUserPointer, const size_t inByteCount)
Constructs me from a client-supplied address and size.
Definition: ntv2publicinterface.cpp:1632
NTV2DeviceIDSetConstIter
NTV2DeviceIDSet::const_iterator NTV2DeviceIDSetConstIter
A convenient const iterator for NTV2DeviceIDSet.
Definition: ntv2utils.h:1041
NTV2Buffer::PutU32s
bool PutU32s(const ULWordSequence &inU32s, const size_t inU32Offset=0, const bool inByteSwap=false)
Copies a vector of unsigned 32-bit values into me.
Definition: ntv2publicinterface.cpp:798
NTV2BufferLock
This is used to prelock a video/audio/anc buffer used as the source or target of DMA transfers....
Definition: ntv2publicinterface.h:8681
NTV2Buffer::toHexString
bool toHexString(std::string &outStr, const size_t inLineBreakInterval=0) const
Converts my contents into a hex-encoded string.
Definition: ntv2publicinterface.cpp:412
AUTOCIRCULATE_TRANSFER_STRUCT::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4232
AUTOCIRCULATE_TRANSFER::SetAncBuffers
bool SetAncBuffers(ULWord *pInANCBuffer, const ULWord inANCByteCount, ULWord *pInANCF2Buffer=NULL, const ULWord inANCF2ByteCount=0)
Sets my ancillary data buffers for use in a subsequent call to CNTV2Card::AutoCirculateTransfer.
Definition: ntv2publicinterface.cpp:2867
NTV2_INVALID_HDMI_AUDIO_CHANNELS
@ NTV2_INVALID_HDMI_AUDIO_CHANNELS
Definition: ntv2enums.h:3642
NTV2AudioChannelQuadsConstIter
NTV2AudioChannelQuads::const_iterator NTV2AudioChannelQuadsConstIter
Handy const iterator to iterate over a set of distinct NTV2AudioChannelQuad values.
Definition: ntv2publicinterface.h:63
NTV2Buffer::Dump
std::ostream & Dump(std::ostream &inOutputStream=std::cout, const size_t inStartByteOffset=0, const size_t inByteCount=0, const size_t inRadix=16, const size_t inBytesPerGroup=4, const size_t inGroupsPerLine=8, const size_t inAddressRadix=0, const bool inShowAscii=false, const size_t inAddrOffset=0) const
Dumps me in hex/octal/decimal, with/without Ascii, to the given output stream.
NTV2ChannelSetConstIter
NTV2ChannelSet::const_iterator NTV2ChannelSetConstIter
A handy const iterator into an NTV2ChannelSet.
Definition: ntv2publicinterface.h:3870
NTV2PixelFormat
NTV2FrameBufferFormat NTV2PixelFormat
An alias for NTV2FrameBufferFormat.
Definition: ntv2enums.h:251
NTV2TimeCodesConstIter
NTV2TimeCodes::const_iterator NTV2TimeCodesConstIter
A handy const interator for iterating over NTV2TCIndex/NTV2TimeCodeList pairs.
Definition: ntv2publicinterface.h:7005
kVRegShiftHDMOutColorRGB
@ kVRegShiftHDMOutColorRGB
Definition: ntv2virtualregisters.h:666
NTV2DeviceCanDoFrameBufferFormat
bool NTV2DeviceCanDoFrameBufferFormat(const NTV2DeviceID inDeviceID, const NTV2FrameBufferFormat inFBFormat)
Definition: ntv2devicefeatures.hpp:16044
NTV2SDIInStatistics::NTV2SDIInStatistics
NTV2SDIInStatistics()
Constructs an NTV2GetSDIStatistics struct and initializes it to its default state.
Definition: ntv2publicinterface.cpp:2459
NTV2SDIInputStatus::NTV2SDIInputStatus
NTV2SDIInputStatus()
Constructs a default NTV2SDIInputStatus.
Definition: ntv2publicinterface.cpp:113
AUTOCIRCULATE_TRANSFER::SetOutputTimeCode
bool SetOutputTimeCode(const NTV2_RP188 &inTimecode, const NTV2TCIndex inTCIndex=NTV2_TCINDEX_SDI1)
Intended for playout, sets one element of my acOutputTimeCodes member.
Definition: ntv2publicinterface.cpp:2898
ntv2debug.h
NTV2GetRegisters::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3317
NTV2HDMIOutputStatus::Clear
void Clear(void)
Resets me to an invalid state.
Definition: ntv2publicinterface.cpp:149
BIN032
#define BIN032(__x__)
Definition: ntv2publicinterface.h:5709
NTV2DebugLogging::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3005
kVRegShiftHDMOutProtocol
@ kVRegShiftHDMOutProtocol
Definition: ntv2virtualregisters.h:669
NTV2SetRegisters::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:7725
NTV2_TYPE_GETREGS
#define NTV2_TYPE_GETREGS
Identifies NTV2GetRegisters struct.
Definition: ntv2publicinterface.h:5577
nlohmann::json_abiNLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON_v3_11_NLOHMANN_JSON_VERSION_PATCH::detail::void
j template void())
Definition: json.hpp:4893
NTV2AutoCirculateStateToString
string NTV2AutoCirculateStateToString(const NTV2AutoCirculateState inState)
Definition: ntv2publicinterface.cpp:1433
ePrerollAutoCirculate
@ ePrerollAutoCirculate
Definition: ntv2publicinterface.h:4356
AUTOCIRCULATE_DATA::bVal6
BOOL_ bVal6
Definition: ntv2publicinterface.h:4491
NTV2_IOKINDS_ANALOG
@ NTV2_IOKINDS_ANALOG
Specifies analog input/output kinds.
Definition: ntv2enums.h:1285
NTV2HDMIRange
NTV2HDMIRange
Indicates or specifies the HDMI RGB range.
Definition: ntv2enums.h:3605
FRAME_STAMP::acAudioExpectedAddress
ULWord acAudioExpectedAddress
Audio transfer address.
Definition: ntv2publicinterface.h:7950
AUTOCIRCULATE_STATUS_STRUCT::audioClockStartTime
ULWord64 audioClockStartTime
Definition: ntv2publicinterface.h:4426
FRAME_STAMP_STRUCT::currentReps
ULWord currentReps
At Call Line# currently being OUTPUT (at the time of the IOCTL_NTV2_GET_FRAMESTAMP)
Definition: ntv2publicinterface.h:4619
AUTOCIRCULATE_STATUS::acRDTSCCurrentTime
ULWord64 acRDTSCCurrentTime
Timestamp when CNTV2Card::AutoCirculateGetStatus called, using the host OS system clock.
Definition: ntv2publicinterface.h:7330
NTV2RegWrites
std::vector< NTV2RegInfo > NTV2RegWrites
An ordered sequence of zero or more NTV2RegInfo structs intended for WriteRegister.
Definition: ntv2publicinterface.h:4069
NTV2_TRAILER
All new NTV2 structs end with this common trailer.
Definition: ntv2publicinterface.h:7167
FRAME_STAMP::acTotalBytesTransferred
ULWord acTotalBytesTransferred
Total audio and video bytes transferred.
Definition: ntv2publicinterface.h:7959
NTV2FrameRate
NTV2FrameRate
Identifies a particular video frame rate.
Definition: ntv2enums.h:403
AJA_DebugStat_ACXferRPCDecode
@ AJA_DebugStat_ACXferRPCDecode
Definition: debugshare.h:249
kVRegMaskHDMOutVideoFrameRate
@ kVRegMaskHDMOutVideoFrameRate
Definition: ntv2virtualregisters.h:645
AutoCircGenericTask
Definition: ntv2publicinterface.h:4832
NTV2ColorCorrectionMode
NTV2ColorCorrectionMode
Definition: ntv2enums.h:2065
NTV2SDKVersionDecode_Minor
#define NTV2SDKVersionDecode_Minor
Definition: ntv2publicinterface.h:5492
FRAME_STAMP::acCurrentFrameTime
LWord64 acCurrentFrameTime
The VBI timestamp of the current/active frame currently being ingested on the device (capture),...
Definition: ntv2publicinterface.h:7990
FRAME_STAMP
This class/object reports information about the current and/or requested AutoCirculate frame.
Definition: ntv2publicinterface.h:7931
NTV2VirtualData::mTag
ULWord mTag
Tag for virtual data. This value is used to recal saved data by tag.
Definition: ntv2publicinterface.h:7834
NTV2SDIInputStatus
For devices that support it (see NTV2DeviceCanDoSDIErrorChecks ), this struct reports SDI input error...
Definition: ntv2publicinterface.h:7024
NTV2AudioChannelQuadToString
std::string NTV2AudioChannelQuadToString(const NTV2Audio4ChannelSelect inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6495
NTV2DeviceGetSupportedInputSources
bool NTV2DeviceGetSupportedInputSources(const NTV2DeviceID inDeviceID, NTV2InputSourceSet &outInputSources, const NTV2IOKinds inKinds)
Returns a set of distinct NTV2InputSource values supported on the given device.
Definition: ntv2publicinterface.cpp:1354
NTV2Buffer::IsPageAligned
bool IsPageAligned(void) const
Definition: ntv2publicinterface.h:6232
AUTOCIRCULATE_STATUS_STRUCT::framesProcessed
ULWord framesProcessed
Definition: ntv2publicinterface.h:4429
NTV2DeviceCanDoVideoFormat
bool NTV2DeviceCanDoVideoFormat(const NTV2DeviceID inDeviceID, const NTV2VideoFormat inVideoFormat)
Definition: ntv2devicefeatures.hpp:19327
FRAME_STAMP::operator=
FRAME_STAMP & operator=(const FRAME_STAMP &inRHS)
Definition: ntv2publicinterface.cpp:2327
NTV2SegmentedDMAInfo::acSegmentDevicePitch
ULWord acSegmentDevicePitch
Offset, in bytes, between the start of one device segment and the start of the next device segment (i...
Definition: ntv2publicinterface.h:7213
NTV2OutputDest
enum NTV2OutputDestination NTV2OutputDest
NTV2BankSelGetSetRegs::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3867
NTV2SegmentedXferInfo::setDestDirection
NTV2SegmentedXferInfo & setDestDirection(const bool inTopDown)
Sets the scan direction for the destination.
Definition: ntv2publicinterface.h:6042
FRAME_STAMP::acCurrentAudioStartAddress
ULWord acCurrentAudioStartAddress
As set by play.
Definition: ntv2publicinterface.h:8002
operator+=
NTV2TCIndexes & operator+=(NTV2TCIndexes &inOutSet, const NTV2TCIndexes &inSet)
Appends the given NTV2TCIndexes contents into the given set.
Definition: ntv2publicinterface.cpp:939
NTV2AudioChannelQuads
std::set< NTV2AudioChannelQuad > NTV2AudioChannelQuads
A set of distinct NTV2AudioChannelQuad values.
Definition: ntv2publicinterface.h:62
NTV2RegNumSet
NTV2RegisterNumberSet NTV2RegNumSet
A set of distinct NTV2RegisterNumbers.
Definition: ntv2publicinterface.h:7577
NTV2BufferLock::SetFlags
void SetFlags(const ULWord inFlags)
Sets the action flags for use in a subsequent call to CNTV2Card::DMABufferLock.
Definition: ntv2publicinterface.h:8747
NTV2GetUnsupportedStandards
bool NTV2GetUnsupportedStandards(NTV2StandardSet &outStandards)
Returns a set of NTV2Standard values not suported by any NTV2 device.
Definition: ntv2publicinterface.cpp:1258
NTV2_TYPE_AJABUFFERLOCK
#define NTV2_TYPE_AJABUFFERLOCK
Identifies NTV2BufferLock struct.
Definition: ntv2publicinterface.h:5581
DEVICE_ID_CORVID44_8K
@ DEVICE_ID_CORVID44_8K
See Corvid 44 12G.
Definition: ntv2enums.h:28
AUTOCIRCULATE_TRANSFER::acTrailer
NTV2_TRAILER acTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8296
NTV2BankSelGetSetRegs
This is used to atomically perform bank-selected register reads or writes.
Definition: ntv2publicinterface.h:7782
AUTOCIRCULATE_STATUS::acState
NTV2AutoCirculateState acState
Current AutoCirculate state.
Definition: ntv2publicinterface.h:7324
FRAME_STAMP_STRUCT::currentLineCount
ULWord currentLineCount
Definition: ntv2publicinterface.h:4618
NTV2SegmentedXferInfo
Describes a segmented data transfer (copy or move) from a source memory location to a destination loc...
Definition: ntv2publicinterface.h:5849
AUTOCIRCULATE_TRANSFER::acInSegmentedDMAInfo
NTV2SegmentedDMAInfo acInSegmentedDMAInfo
Optional segmented DMA info, for use with specialized data transfers.
Definition: ntv2publicinterface.h:8277
FRAME_STAMP_STRUCT::startSample
ULWord startSample
Definition: ntv2publicinterface.h:4586
NTV2StreamChannel::NTV2StreamChannel
NTV2StreamChannel()
Constructs a default NTV2StreamChannel struct.
Definition: ntv2publicinterface.cpp:3098
NTV2_QuarterSizeExpandOff
@ NTV2_QuarterSizeExpandOff
Definition: ntv2enums.h:2474
NTV2Buffer::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me into the given output stream.
Definition: ntv2publicinterface.cpp:387
AUTOCIRCULATE_STATUS::IsInput
bool IsInput(void) const
Definition: ntv2publicinterface.h:7541
NTV2BufferLock::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8682
FRAME_STAMP::acAudioInStartAddress
ULWord acAudioInStartAddress
(input/ingest/capture only) Starting audio record head position when this frame was stamped.
Definition: ntv2publicinterface.h:7951
NTV2_INPUTSOURCE_ANALOG1
@ NTV2_INPUTSOURCE_ANALOG1
Identifies the first analog video input.
Definition: ntv2enums.h:1255
AUTOCIRCULATE_WITH_ANC
#define AUTOCIRCULATE_WITH_ANC
Use this to AutoCirculate with ancillary data.
Definition: ntv2publicinterface.h:5634
NTV2_TYPE_ACXFERSTATUS
#define NTV2_TYPE_ACXFERSTATUS
Identifies AUTOCIRCULATE_TRANSFER_STATUS struct.
Definition: ntv2publicinterface.h:5574
NTV2HDMIAudioChannelsToString
std::string NTV2HDMIAudioChannelsToString(const NTV2HDMIAudioChannels inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6709
ntv2nub::PUSHU64
void PUSHU64(const uint64_t inVal, std::vector< uint8_t > &inArr, const bool dontSwap=false)
Definition: ntv2nubtypes.h:46
AUTOCIRCULATE_DATA::lVal3
LWord lVal3
Definition: ntv2publicinterface.h:4481
NTV2RegInfo::Print
std::ostream & Print(std::ostream &outputStream, const bool inAsCode=false) const
Renders me to the given output stream in a human-readable format.
Definition: ntv2publicinterface.cpp:3418
AJAMemory::FreeAligned
static void FreeAligned(void *pMemory)
Definition: memory.cpp:145
AUTO_CIRC_COMMAND
enum _AutoCircCommand_ AUTO_CIRC_COMMAND
AUTOCIRCULATE_WITH_FBFCHANGE
#define AUTOCIRCULATE_WITH_FBFCHANGE
Use this to AutoCirculate with the possibility of frame buffer format changes.
Definition: ntv2publicinterface.h:5630
NTV2Buffer::GetRingChangedByteRange
bool GetRingChangedByteRange(const NTV2Buffer &inBuffer, ULWord &outByteOffsetFirst, ULWord &outByteOffsetLast) const
Assuming my contents and the contents of the given buffer comprise ring buffers that periodically get...
Definition: ntv2publicinterface.cpp:2069
NTV2_IOKINDS_SDI
@ NTV2_IOKINDS_SDI
Specifies SDI input/output kinds.
Definition: ntv2enums.h:1283
eAbortAutoCirc
@ eAbortAutoCirc
Definition: ntv2publicinterface.h:4358
FRAME_STAMP::acTimeCodes
NTV2Buffer acTimeCodes
Intended for capture, this is a sequence of NTV2_RP188 values received from the device (in NTV2TCInde...
Definition: ntv2publicinterface.h:7974
eTransferAutoCirculate
@ eTransferAutoCirculate
Definition: ntv2publicinterface.h:4357
NTV2_RP188::fLo
ULWord fLo
| BG 4 | Secs10 | BG 3 | Secs 1 | BG 2 | Frms10 | BG 1 | Frms 1 |
Definition: ntv2publicinterface.h:6920
NTV2Buffer::DefaultPageSize
static size_t DefaultPageSize(void)
Definition: ntv2publicinterface.cpp:2150
NTV2Bitstream::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8786
NTV2_IS_VALID_IOKINDS
#define NTV2_IS_VALID_IOKINDS(_k_)
Definition: ntv2enums.h:1298
NTV2ColorCorrectionData::ccMode
NTV2ColorCorrectionMode ccMode
My mode (off, RGB, YCbCr, or 3-way)
Definition: ntv2publicinterface.h:7266
NTV2_OUTPUTDESTINATION_SDI1
@ NTV2_OUTPUTDESTINATION_SDI1
Definition: ntv2enums.h:1314
NTV2InputSourceToString
std::string NTV2InputSourceToString(const NTV2InputSource inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:7263
NTV2CROSSPOINT_INVALID
@ NTV2CROSSPOINT_INVALID
Definition: ntv2enums.h:1707
NTV2_FG_4096x2160
@ NTV2_FG_4096x2160
Definition: ntv2enums.h:361
AutoCircVidProcModeToString
std::string AutoCircVidProcModeToString(const AutoCircVidProcMode inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:7763
kRegReserved83
@ kRegReserved83
Definition: ntv2publicinterface.h:187
AUTOCIRCULATE_STATUS::acAudioClockCurrentTime
ULWord64 acAudioClockCurrentTime
Timestamp when CNTV2Card::AutoCirculateGetStatus called, using "64-bit clean" value of the device's 4...
Definition: ntv2publicinterface.h:7331
NTV2_FG_8192x4320
@ NTV2_FG_8192x4320
Definition: ntv2enums.h:365
NTV2TCIndexToString
std::string NTV2TCIndexToString(const NTV2TCIndex inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6446
NTV2_RP188::fHi
ULWord fHi
| BG 8 | Hrs 10 | BG 7 | Hrs 1 | BG 6 | Mins10 | BG 5 | Mins 1 |
Definition: ntv2publicinterface.h:6921
AutoCircVidProcInfo
Definition: ntv2publicinterface.h:4311
NTV2GetRegisters
This is used by the CNTV2Card::ReadRegisters function.
Definition: ntv2publicinterface.h:7606
AutoCircVidProcInfo::foregroundKeyCrosspoint
NTV2Crosspoint foregroundKeyCrosspoint
Definition: ntv2publicinterface.h:4316
eGetFrameStamp
@ eGetFrameStamp
Definition: ntv2publicinterface.h:4354
NTV2Bitstream::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8792
FRAME_STAMP_STRUCT
Definition: ntv2publicinterface.h:4542
NTV2_FG_2048x1588
@ NTV2_FG_2048x1588
2048x1556, for 2Kx1556psf film format, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:354
ntv2nub::POPU64
void POPU64(uint64_t &outVal, const std::vector< uint8_t > &inArr, std::size_t &inOutNdx, const bool dontSwap=false)
Definition: ntv2nubtypes.h:78
AUTOCIRCULATE_DATA::eCommand
AUTO_CIRC_COMMAND eCommand
Definition: ntv2publicinterface.h:4476
AUTOCIRCULATE_TRANSFER::acFrameBufferOrientation
NTV2FBOrientation acFrameBufferOrientation
Specifies the frame buffer orientation to change to. Ignored if AUTOCIRCULATE_WITH_FBOCHANGE option i...
Definition: ntv2publicinterface.h:8280
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:156
NTV2_MAX_NUM_CHANNELS
@ NTV2_MAX_NUM_CHANNELS
Definition: ntv2enums.h:1353
NTV2EndianSwap16
#define NTV2EndianSwap16(__val__)
Definition: ntv2endian.h:15
NTV2_TRAILER::fTrailerVersion
ULWord fTrailerVersion
Trailer version, set when created. Before SDK 15.1: always zero; 15.1 or later: set to calling SDK ve...
Definition: ntv2publicinterface.h:7168
nlohmann::json_abiNLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON_v3_11_NLOHMANN_JSON_VERSION_PATCH::detail::value_t::string
@ string
string value
AUTOCIRCULATE_STATUS_STRUCT::bWithVidProc
BOOL_ bWithVidProc
Definition: ntv2publicinterface.h:4437
aja::replace
std::string & replace(std::string &str, const std::string &from, const std::string &to)
Definition: common.cpp:110
NTV2AudioChannelPairToString
std::string NTV2AudioChannelPairToString(const NTV2AudioChannelPair inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6483
NTV2Buffer::IsNULL
bool IsNULL(void) const
Definition: ntv2publicinterface.h:6237
NTV2Buffer::GetRawHostPointer
ULWord64 GetRawHostPointer(void) const
Definition: ntv2publicinterface.h:6210
NTV2VirtualData::mIsWriting
ULWord mIsWriting
If non-zero, virtual data will be written; otherwise, virtual data will be read.
Definition: ntv2publicinterface.h:7835
NTV2SegmentedXferInfo::Print
std::ostream & Print(std::ostream &inStrm, const bool inDumpSegments=false) const
Writes a human-readable description of me into a given output stream.
Definition: ntv2publicinterface.cpp:1511
ULWord
uint32_t ULWord
Definition: ajatypes.h:255
ntv2nub
Definition: ntv2nubtypes.h:21
NTV2StreamChannel::mStatus
ULWord mStatus
Action status.
Definition: ntv2publicinterface.h:8912
NTV2_CURRENT_HEADER_VERSION
#define NTV2_CURRENT_HEADER_VERSION
Current version of NTV2_HEADER struct, originally 0.
Definition: ntv2publicinterface.h:5558
AUTOCIRCULATE_STATUS::CopyFrom
bool CopyFrom(const AUTOCIRCULATE_STATUS_STRUCT &inOldStruct)
Copies the given AUTOCIRCULATE_STATUS_STRUCT into me.
Definition: ntv2publicinterface.cpp:2580
FRAME_STAMP::acAudioClockTimeStamp
ULWord64 acAudioClockTimeStamp
(input/ingest/capture only) The absolute timestamp at the VBI when the frame started recording into d...
Definition: ntv2publicinterface.h:7944
NTV2SetRegisters::mInNumRegisters
ULWord mInNumRegisters
The number of NTV2RegInfo's to be set.
Definition: ntv2publicinterface.h:7721
NTV2SDIInputStatus::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me into the given output stream.
Definition: ntv2publicinterface.cpp:133
NTV2AudioSystemSetToStr
string NTV2AudioSystemSetToStr(const NTV2AudioSystemSet &inObj, const bool inCompact)
Definition: ntv2publicinterface.cpp:3572
NTV2SegmentedDMAInfo::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4044
AUTOCIRCULATE_STATUS
This is returned from the CNTV2Card::AutoCirculateGetStatus function.
Definition: ntv2publicinterface.h:7321
NTV2_OUTPUT_DEST_IS_HDMI
#define NTV2_OUTPUT_DEST_IS_HDMI(_dest_)
Definition: ntv2enums.h:1330
AUTOCIRCULATE_STATUS::WithRP188
bool WithRP188(void) const
Definition: ntv2publicinterface.h:7501
AUTOCIRCULATE_TRANSFER::acHeader
NTV2_HEADER acHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8209
NTV2_AUDIOSYSTEM_Plus2
@ NTV2_AUDIOSYSTEM_Plus2
Definition: ntv2enums.h:3879
AutoCircVidProcInfo::mode
AutoCircVidProcMode mode
Definition: ntv2publicinterface.h:4313
FRAME_STAMP::~FRAME_STAMP
~FRAME_STAMP()
My destructor.
Definition: ntv2publicinterface.cpp:2233
NTV2_CCMODE_3WAY
@ NTV2_CCMODE_3WAY
Definition: ntv2enums.h:2070
NTV2FrameSize::FGSizesMap
std::map< NTV2FrameGeometry, ULWord > FGSizesMap
Definition: ntv2publicinterface.h:5818
CNTV2RegisterExpert::GetDisplayName
static std::string GetDisplayName(const uint32_t inRegNum)
Definition: ntv2registerexpert.cpp:4651
NTV2DeviceGetSupportedStandards
bool NTV2DeviceGetSupportedStandards(const NTV2DeviceID inDeviceID, NTV2StandardSet &outStandards)
Returns a set of distinct NTV2Standard values supported on the given device.
Definition: ntv2publicinterface.cpp:1323
AUTOCIRCULATE_TRANSFER::acVideoQuarterSizeExpand
NTV2QuarterSizeExpandMode acVideoQuarterSizeExpand
Turns on the "quarter-size expand" (2x H + 2x V) hardware. Defaults to off (1:1).
Definition: ntv2publicinterface.h:8282
ThousandsSeparator
Definition: ntv2publicinterface.cpp:2632
NTV2EndianSwap32
#define NTV2EndianSwap32(__val__)
Definition: ntv2endian.h:19
AUTOCIRCULATE_TRANSFER_STATUS::acHeader
NTV2_HEADER acHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8120
AUTOCIRCULATE_DATA::lVal1
LWord lVal1
Definition: ntv2publicinterface.h:4479
NTV2PrintULWordVector
ostream & NTV2PrintULWordVector(const NTV2ULWordVector &inObj, ostream &inOutStream)
Definition: ntv2publicinterface.cpp:3473
NTV2_FG_720x612
@ NTV2_FG_720x612
720x576, for PAL 625i, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:357
NTV2GetUnsupportedPixelFormats
bool NTV2GetUnsupportedPixelFormats(NTV2PixelFormats &outFormats)
Returns a set of NTV2PixelFormat values not suported by any NTV2 device.
Definition: ntv2publicinterface.cpp:1233
BIN08
#define BIN08(__x__)
Definition: ntv2publicinterface.h:5717
NTV2FrameRateSetConstIter
NTV2FrameRateSet::const_iterator NTV2FrameRateSetConstIter
A handy const iterator for iterating over an NTV2FrameRateSet.
Definition: ntv2publicinterface.h:9029
AUTOCIRCULATE_TRANSFER::SetOutputTimeCodes
bool SetOutputTimeCodes(const NTV2TimeCodes &inValues)
Intended for playout, replaces the contents of my acOutputTimeCodes member.
Definition: ntv2publicinterface.cpp:2878
NTV2ColorCorrectionData::~NTV2ColorCorrectionData
~NTV2ColorCorrectionData()
My destructor, which frees my private color correction table buffer.
Definition: ntv2publicinterface.cpp:2751
FRAME_STAMP::GetInputTimeCodes
bool GetInputTimeCodes(NTV2TimeCodeList &outValues) const
Returns all RP188 timecodes associated with the frame in NTV2TCIndex order.
Definition: ntv2publicinterface.cpp:2238
NTV2Buffer::IsAllocatedBySDK
bool IsAllocatedBySDK(void) const
Definition: ntv2publicinterface.h:6221
UWordSequenceConstIter
UWordSequence::const_iterator UWordSequenceConstIter
A handy const iterator for iterating over a UWordSequence.
Definition: ntv2publicinterface.h:43
UWordSequence
std::vector< uint16_t > UWordSequence
An ordered sequence of UWord (uint16_t) values.
Definition: ntv2publicinterface.h:42
AUTOCIRCULATE_STATUS::acActiveFrame
LWord acActiveFrame
Current frame actually being captured/played when CNTV2Card::AutoCirculateGetStatus called....
Definition: ntv2publicinterface.h:7327
NTV2GeometrySet
std::set< NTV2FrameGeometry > NTV2GeometrySet
A set of distinct NTV2FrameGeometry values.
Definition: ntv2publicinterface.h:9016
FRAME_STAMP::acStartSample
ULWord acStartSample
The actual audio start sample when this frame was started at the VBI, which may be used to check sync...
Definition: ntv2publicinterface.h:7960
AUTOCIRCULATE_TRANSFER_STRUCT
Definition: ntv2publicinterface.h:4679
AUTOCIRCULATE_TASK_STRUCT::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4417
NTV2_CCMODE_INVALID
@ NTV2_CCMODE_INVALID
Definition: ntv2enums.h:2072
NTV2HDMIProtocol
NTV2HDMIProtocol
Indicates or specifies the HDMI protocol.
Definition: ntv2enums.h:3591
NTV2_IS_VALID_STANDARD
#define NTV2_IS_VALID_STANDARD(__s__)
Definition: ntv2enums.h:179
NTV2AudioSystemSet
std::set< NTV2AudioSystem > NTV2AudioSystemSet
A set of distinct NTV2AudioSystem values. New in SDK 16.2.
Definition: ntv2publicinterface.h:3915
oOCT
#define oOCT(__x__)
Definition: ntv2publicinterface.h:5699
NTV2_MAX_NUM_VIDEO_FORMATS
@ NTV2_MAX_NUM_VIDEO_FORMATS
Definition: ntv2enums.h:713
FRAME_STAMP::acAudioInStopAddress
ULWord acAudioInStopAddress
(input/ingest/capture only) Ending audio record head position (exclusive) AFTER this frame was stampe...
Definition: ntv2publicinterface.h:7953
AutoCircVidProcInfo::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4077
eFlushAutoCirculate
@ eFlushAutoCirculate
Definition: ntv2publicinterface.h:4355
kVRegShiftHDMOutRangeFull
@ kVRegShiftHDMOutRangeFull
Definition: ntv2virtualregisters.h:667
FRAME_STAMP::GetSDIInputStatus
bool GetSDIInputStatus(NTV2SDIInputStatus &outStatus, const UWord inSDIInputIndex0=0) const
Answers with the NTV2SDIInputStatus for the given SDI input spigot.
Definition: ntv2publicinterface.cpp:2302
NTV2StreamChannel::Print
std::ostream & Print(std::ostream &inOutStream) const
Definition: ntv2publicinterface.cpp:3104
NTV2_RP188::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4108
NTV2SetRegisters::ResetUsing
bool ResetUsing(const NTV2RegWrites &inRegWrites)
Resets me, starting over, now using the given NTV2RegisterNumberSet.
Definition: ntv2publicinterface.cpp:3334
AUTOCIRCULATE_STATUS_STRUCT::bFbfChange
BOOL_ bFbfChange
Definition: ntv2publicinterface.h:4434
NTV2TCIndex
NTV2TCIndex
These enum values are indexes into the capture/playout AutoCirculate timecode arrays.
Definition: ntv2enums.h:3921
AUTOCIRCULATE_TRANSFER_STATUS::acBufferLevel
ULWord acBufferLevel
The number of frames ready to record/play after the transfer.
Definition: ntv2publicinterface.h:8123
eGetAutoCirc
@ eGetAutoCirc
Definition: ntv2publicinterface.h:4353
ntv2nub::POPU8
void POPU8(uint8_t &outVal, const std::vector< uint8_t > &inArr, std::size_t &inOutNdx)
Definition: ntv2nubtypes.h:56
AUTOCIRCULATE_STATUS::GetActiveFrame
LWord GetActiveFrame(void) const
Definition: ntv2publicinterface.h:7436
NTV2Buffer::ByteSwap32
bool ByteSwap32(void)
Byte-swaps my contents 32-bits at a time.
Definition: ntv2publicinterface.cpp:1729
NTV2RegisterReadsConstIter
NTV2RegWritesConstIter NTV2RegisterReadsConstIter
Definition: ntv2publicinterface.h:4073
AUTOCIRCULATE_STATUS::AUTOCIRCULATE_STATUS
AUTOCIRCULATE_STATUS(const NTV2Crosspoint inCrosspoint=NTV2CROSSPOINT_CHANNEL1)
Constructs a default AUTOCIRCULATE_STATUS struct for the given NTV2Crosspoint.
Definition: ntv2publicinterface.cpp:2533
AUTOCIRCULATE_DATA::lVal2
LWord lVal2
Definition: ntv2publicinterface.h:4480
NTV2_OUTPUTDESTINATION_SDI6
@ NTV2_OUTPUTDESTINATION_SDI6
Definition: ntv2enums.h:1319
NTV2StandardToString
std::string NTV2StandardToString(const NTV2Standard inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6962
AUTOCIRCULATE_TRANSFER::acDesiredFrame
LWord acDesiredFrame
Used to specify a different frame in the circulate ring to transfer to/from.
Definition: ntv2publicinterface.h:8292
NTV2Bitstream::SetBuffer
bool SetBuffer(const NTV2Buffer &inBuffer)
Sets the buffer to lock for use in a subsequent call to CNTV2Card::LoadBitstream.
Definition: ntv2publicinterface.cpp:3085
FRAME_STAMP::SetFrom
bool SetFrom(const FRAME_STAMP_STRUCT &inOldStruct)
Sets my fields from the given FRAME_STAMP_STRUCT.
Definition: ntv2publicinterface.cpp:2361
AutoCircVidProcInfo::AutoCircVidProcInfo
AutoCircVidProcInfo()
Definition: ntv2publicinterface.cpp:203
NTV2_HDMIColorSpaceYCbCr
@ NTV2_HDMIColorSpaceYCbCr
YCbCr color space.
Definition: ntv2enums.h:3579
NTV2_TYPE_SDISTATS
#define NTV2_TYPE_SDISTATS
Identifies NTV2SDIStatus struct.
Definition: ntv2publicinterface.h:5579
AUTOCIRCULATE_STATUS_STRUCT::channelSpec
NTV2Crosspoint channelSpec
Definition: ntv2publicinterface.h:4420
NTV2BufferLock::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8688
NTV2Bitstream::mFlags
ULWord mFlags
Action flags (lock, unlock, etc)
Definition: ntv2publicinterface.h:8788
NTV2Buffer::PutU16s
bool PutU16s(const UWordSequence &inU16s, const size_t inU16Offset=0, const bool inByteSwap=false)
Copies a vector of unsigned 16-bit values into me.
Definition: ntv2publicinterface.cpp:826
FRAME_STAMP::acHeader
NTV2_HEADER acHeader
The common message header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:7932
AUTOCIRCULATE_TRANSFER::acCrosspoint
NTV2Crosspoint acCrosspoint
Will be deprecated – used internally by the SDK. Will be removed when the driver changes to use NTV2C...
Definition: ntv2publicinterface.h:8294
NTV2_FG_720x514
@ NTV2_FG_720x514
720x486, for NTSC 525i and 525p60, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:356
kVRegMaskHDMOutAudioRate
@ kVRegMaskHDMOutAudioRate
Definition: ntv2virtualregisters.h:652
NTV2_FG_3840x2160
@ NTV2_FG_3840x2160
Definition: ntv2enums.h:359
AUTOCIRCULATE_DATA::AUTOCIRCULATE_DATA
AUTOCIRCULATE_DATA(const AUTO_CIRC_COMMAND inCommand=AUTO_CIRC_COMMAND_INVALID, const NTV2Crosspoint inCrosspoint=NTV2CROSSPOINT_INVALID)
Definition: ntv2publicinterface.cpp:215
NTV2Buffer::IsContentEqual
bool IsContentEqual(const NTV2Buffer &inBuffer, const ULWord inByteOffset=0, const ULWord inByteCount=0xFFFFFFFF) const
Definition: ntv2publicinterface.cpp:1994
NTV2_HEADER
All new NTV2 structs start with this common header.
Definition: ntv2publicinterface.h:7112
NTV2_OUTPUT_DEST_IS_ANALOG
#define NTV2_OUTPUT_DEST_IS_ANALOG(_dest_)
Definition: ntv2enums.h:1331
NTV2Buffer::CopyFrom
bool CopyFrom(const void *pInSrcBuffer, const ULWord inByteCount)
Replaces my contents from the given memory buffer, resizing me to the new byte count.
Definition: ntv2publicinterface.cpp:1857
NTV2_IS_VALID_STRUCT_TYPE
#define NTV2_IS_VALID_STRUCT_TYPE(_x_)
Definition: ntv2publicinterface.h:5596
aja::upper
std::string & upper(std::string &str)
Definition: common.cpp:442
UWord
uint16_t UWord
Definition: ajatypes.h:253
NTV2RegisterReads
NTV2RegWrites NTV2RegisterReads
Definition: ntv2publicinterface.h:4072
DEVICE_ID_KONAIP_25G
@ DEVICE_ID_KONAIP_25G
See KONA IP25.
Definition: ntv2enums.h:72
sSegXferUnits
static const string sSegXferUnits[]
Definition: ntv2publicinterface.cpp:1509
NTV2_RP188::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4116
NTV2_TRAILER::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3724
AUTOCIRCULATE_DATA::bVal5
BOOL_ bVal5
Definition: ntv2publicinterface.h:4490
AUTOCIRCULATE_STATUS_STRUCT::state
NTV2AutoCirculateState state
Definition: ntv2publicinterface.h:4421
AUTOCIRCULATE_TRANSFER
This object specifies the information that will be transferred to or from the AJA device in the CNTV2...
Definition: ntv2publicinterface.h:8208
NTV2_OUTPUTDESTINATION_SDI8
@ NTV2_OUTPUTDESTINATION_SDI8
Definition: ntv2enums.h:1321
ntv2utils.h
Declares numerous NTV2 utility functions.
NTV2ColorCorrectionData
Color correction data used with AUTOCIRCULATE_WITH_COLORCORRECT option.
Definition: ntv2publicinterface.h:7265
FRAME_STAMP::acFrame
ULWord acFrame
(input/ingest/capture only) Current/active frame number.
Definition: ntv2publicinterface.h:8010
NTV2_TYPE_AJADEBUGLOGGING
#define NTV2_TYPE_AJADEBUGLOGGING
Identifies NTV2DebugLogging struct.
Definition: ntv2publicinterface.h:5580
YesNo
#define YesNo(__x__)
Definition: ntv2registerexpert.h:25
NTV2VideoFormatToString
std::string NTV2VideoFormatToString(const NTV2VideoFormat inValue, const bool inUseFrameRate=false)
Definition: ntv2utils.cpp:6798
NTV2VideoFormatSetConstIter
NTV2VideoFormatSet::const_iterator NTV2VideoFormatSetConstIter
A handy const iterator for iterating over an NTV2VideoFormatSet.
Definition: ntv2publicinterface.h:9009
AUTOCIRCULATE_TRANSFER_STATUS::acTrailer
NTV2_TRAILER acTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8131
AUTOCIRCULATE_DATA::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4534
NTV2_INPUT_SOURCE_IS_HDMI
#define NTV2_INPUT_SOURCE_IS_HDMI(_inpSrc_)
Definition: ntv2enums.h:1272
NTV2DeviceGetSupportedGeometries
bool NTV2DeviceGetSupportedGeometries(const NTV2DeviceID inDeviceID, NTV2GeometrySet &outGeometries)
Returns a set of distinct NTV2FrameGeometry values supported on the given device.
Definition: ntv2publicinterface.cpp:1339
NTV2_MAX_NUM_TIMECODE_INDEXES
@ NTV2_MAX_NUM_TIMECODE_INDEXES
Definition: ntv2enums.h:3950
AUTOCIRCULATE_TRANSFER::SetVideoBuffer
bool SetVideoBuffer(ULWord *pInVideoBuffer, const ULWord inVideoByteCount)
Sets my video buffer for use in a subsequent call to CNTV2Card::AutoCirculateTransfer.
Definition: ntv2publicinterface.cpp:2851
NTV2BankSelGetSetRegs::GetRegInfo
NTV2RegInfo GetRegInfo(const UWord inIndex0=0) const
Definition: ntv2publicinterface.cpp:3636
NTV2HDMIRangeToString
std::string NTV2HDMIRangeToString(const NTV2HDMIRange inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6731
FRAME_STAMP::acCurrentLineCount
ULWord acCurrentLineCount
At Call Line# currently being OUTPUT (at the time of the IOCTL_NTV2_GET_FRAMESTAMP)
Definition: ntv2publicinterface.h:8004
NTV2VirtualData::NTV2VirtualData
NTV2VirtualData(const ULWord inTag, const void *inVirtualData, const size_t inVirtualDataSize, const bool inDoWrite=false)
Constructs an NTV2VirtualData struct for reading or writing virtual data.
Definition: ntv2publicinterface.cpp:3664
FRAME_STAMP_STRUCT::audioClockCurrentTime
ULWord64 audioClockCurrentTime
48kHz clock in reg 28 extended to 64 bits
Definition: ntv2publicinterface.h:4606
AsU64Ref
#define AsU64Ref(_x_)
Definition: ntv2publicinterface.cpp:3689
NTV2SDKVersionEncode
#define NTV2SDKVersionEncode
Definition: ntv2publicinterface.h:5490
NTV2Bitstream::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4309
AUTOCIRCULATE_STATUS::IsStopped
bool IsStopped(void) const
Definition: ntv2publicinterface.h:7471
NTV2Buffer::GetString
bool GetString(std::string &outString, const size_t inU8Offset=0, const size_t inMaxSize=128) const
Answers with my contents as a character string.
Definition: ntv2publicinterface.cpp:730
ThousandsSeparator::do_thousands_sep
virtual char do_thousands_sep() const
Definition: ntv2publicinterface.cpp:2634
AUTOCIRCULATE_TRANSFER::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4158
NTV2Buffer::Segment
NTV2Buffer & Segment(NTV2Buffer &outPtr, const ULWord inByteOffset, const ULWord inByteCount) const
Resets an NTV2Buffer instance to reference a contiguous segment (portion) of my memory buffer.
Definition: ntv2publicinterface.cpp:555
AUTOCIRCULATE_STATUS_STRUCT::startFrame
LWord startFrame
Definition: ntv2publicinterface.h:4422
NTV2RegInfo::value
ULWord value(void) const
Definition: ntv2publicinterface.h:4056
AUTOCIRCULATE_STATUS::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3882
NTV2ULWordVector
std::vector< ULWord > NTV2ULWordVector
An ordered sequence of ULWords.
Definition: ntv2publicinterface.h:3840
FRAME_STAMP::operator[]
std::string operator[](const unsigned inIndexNum) const
Definition: ntv2publicinterface.cpp:2439
AUTOCIRCULATE_TRANSFER::acColorCorrection
NTV2ColorCorrectionData acColorCorrection
Color correction data. This field is ignored if AUTOCIRCULATE_WITH_COLORCORRECT option is not set.
Definition: ntv2publicinterface.h:8278
AUTOCIRCULATE_DATA::lVal4
LWord lVal4
Definition: ntv2publicinterface.h:4482
eStartAutoCirc
@ eStartAutoCirc
Definition: ntv2publicinterface.h:4350
DEVICE_ID_INVALID
@ DEVICE_ID_INVALID
Definition: ntv2enums.h:93
NTV2Buffer::GetU64s
bool GetU64s(ULWord64Sequence &outU64s, const size_t inU64Offset=0, const size_t inMaxSize=16, const bool inByteSwap=false) const
Answers with my contents as a vector of unsigned 16-bit values.
Definition: ntv2publicinterface.cpp:567
NTV2_NUM_INPUTSOURCES
@ NTV2_NUM_INPUTSOURCES
Definition: ntv2enums.h:1269
NTV2AudioChannelOctetToString
std::string NTV2AudioChannelOctetToString(const NTV2Audio8ChannelSelect inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6507
NTV2_FG_1280x720
@ NTV2_FG_1280x720
1280x720, for 720p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:343
FRAME_STAMP_STRUCT::frameTime
LWord64 frameTime
Definition: ntv2publicinterface.h:4552
NTV2HDMIProtocolToString
std::string NTV2HDMIProtocolToString(const NTV2HDMIProtocol inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6720
NTV2Buffer::U8
uint8_t U8(const int inIndex) const
Definition: ntv2publicinterface.h:6664
NTV2AudioChannelOctetsConstIter
NTV2AudioChannelOctets::const_iterator NTV2AudioChannelOctetsConstIter
Handy const iterator to iterate over a set of distinct NTV2AudioChannelOctet values.
Definition: ntv2publicinterface.h:67
NTV2_TYPE_ACFRAMESTAMP
#define NTV2_TYPE_ACFRAMESTAMP
Identifies FRAME_STAMP struct.
Definition: ntv2publicinterface.h:5576
AUTOCIRCULATE_STATUS::GetChannel
NTV2Channel GetChannel(void) const
Definition: ntv2publicinterface.cpp:2626
NTV2_RP188::fDBB
ULWord fDBB
Definition: ntv2publicinterface.h:6919
NTV2BankSelGetSetRegs::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3651
NTV2ChannelSet
std::set< NTV2Channel > NTV2ChannelSet
A set of distinct NTV2Channel values.
Definition: ntv2publicinterface.h:3869
ntv2version.h
Defines for the NTV2 SDK version number, used by ajantv2/includes/ntv2enums.h. See the ajantv2/includ...
AUTOCIRCULATE_STATUS_STRUCT::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4323
AUTOCIRCULATE_TRANSFER_STATUS::acFrameStamp
FRAME_STAMP acFrameStamp
Frame stamp for the transferred frame.
Definition: ntv2publicinterface.h:8126
AUTOCIRCULATE_TRANSFER_STATUS
This object is embedded in the AUTOCIRCULATE_TRANSFER struct that's returned from the CNTV2Card::Auto...
Definition: ntv2publicinterface.h:8119
AUTOCIRCULATE_TRANSFER::acANCField2Buffer
NTV2Buffer acANCField2Buffer
The host "Field 2" ancillary data buffer. This field is owned by the client application,...
Definition: ntv2publicinterface.h:8245
NTV2_FBF_FIRST
@ NTV2_FBF_FIRST
Definition: ntv2enums.h:212
CRP188
Definition: ntv2rp188.h:55
AUTOCIRCULATE_STATUS::GetEndFrame
uint16_t GetEndFrame(void) const
Definition: ntv2publicinterface.h:7446
NTV2Buffer::~NTV2Buffer
~NTV2Buffer()
My destructor. If I'm responsible for the memory, I free it here.
Definition: ntv2publicinterface.cpp:1711
NTV2SetRegisters::mInRegInfos
NTV2Buffer mInRegInfos
Read-only array of NTV2RegInfo structs to be set. The SDK owns this memory.
Definition: ntv2publicinterface.h:7722
AJA_NTV2_SDK_VERSION_MAJOR
#define AJA_NTV2_SDK_VERSION_MAJOR
The SDK major version number, an unsigned decimal integer.
Definition: ntv2version.h:13
NTV2_FRAMEBUFFER_ORIENTATION_TOPDOWN
@ NTV2_FRAMEBUFFER_ORIENTATION_TOPDOWN
Definition: ntv2enums.h:2033
AUTOCIRCULATE_TRANSFER::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4124
AUTOCIRCULATE_STATUS::acBufferLevel
ULWord acBufferLevel
Number of buffered frames in driver ready to capture or play.
Definition: ntv2publicinterface.h:7334
CommaStr
string CommaStr(const T &inNum)
Definition: ntv2publicinterface.cpp:2639
NTV2Buffer::PutU64s
bool PutU64s(const ULWord64Sequence &inU64s, const size_t inU64Offset=0, const bool inByteSwap=false)
Copies a vector of unsigned 64-bit values into me.
Definition: ntv2publicinterface.cpp:770
NTV2Buffer::ByteSwap16
bool ByteSwap16(void)
Byte-swaps my contents 16-bits at a time.
Definition: ntv2publicinterface.cpp:1741
NTV2_INVALID_HDMI_PROTOCOL
@ NTV2_INVALID_HDMI_PROTOCOL
Definition: ntv2enums.h:3596
AutoCircGenericTask::u
union AutoCircGenericTask::@33 u
FRAME_STAMP::acCurrentFieldCount
ULWord acCurrentFieldCount
As found by ISR at Call Field0 or Field1 currently being OUTPUT (when CNTV2Card::AutoCirculateGetFram...
Definition: ntv2publicinterface.h:8003
NTV2_INVALID_HDMI_RANGE
@ NTV2_INVALID_HDMI_RANGE
Definition: ntv2enums.h:3610
AUTOCIRCULATE_STATUS_STRUCT::endFrame
LWord endFrame
Definition: ntv2publicinterface.h:4423
AUTOCIRCULATE_STRUCT_VERSION
#define AUTOCIRCULATE_STRUCT_VERSION
Version number of AutoCirculate structures, originally 0.
Definition: ntv2publicinterface.h:5561
NTV2_OUTPUT_DEST_IS_SDI
#define NTV2_OUTPUT_DEST_IS_SDI(_dest_)
Definition: ntv2enums.h:1332
NTV2AutoCirculateState
NTV2AutoCirculateState
Describes the state of an AutoCirculate channel. See AUTOCIRCULATE_STATUS.
Definition: ntv2publicinterface.h:4375
gDefaultPageSize
static size_t gDefaultPageSize(AJA_PAGE_SIZE)
AJA_NULL
#define AJA_NULL
Definition: ajatypes.h:199
AUTOCIRCULATE_TRANSFER::acTransferStatus
AUTOCIRCULATE_TRANSFER_STATUS acTransferStatus
Contains status information that's valid after CNTV2Card::AutoCirculateTransfer returns,...
Definition: ntv2publicinterface.h:8260
NTV2_IS_VALID_CHANNEL
#define NTV2_IS_VALID_CHANNEL(__x__)
Definition: ntv2enums.h:1357
NTV2RegInfo::registerValue
ULWord registerValue
My register value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:3979
GetRelatedGeometries
NTV2GeometrySet GetRelatedGeometries(const NTV2FrameGeometry inFrameGeometry)
Definition: ntv2utils.cpp:3906
AUTOCIRCULATE_DATA::bVal1
BOOL_ bVal1
Definition: ntv2publicinterface.h:4486
NTV2BankSelGetSetRegs::mInRegInfos
NTV2Buffer mInRegInfos
NTV2RegInfo array of registers be read/written. The SDK owns this memory.
Definition: ntv2publicinterface.h:7786
AUTOCIRCULATE_TRANSFER_STATUS::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4005
GetGeometryFromFrameDimensions
NTV2FrameGeometry GetGeometryFromFrameDimensions(const NTV2FrameDimensions &inFD)
Definition: ntv2utils.cpp:3861
NTV2SegmentedXferInfo::setSourceDirection
NTV2SegmentedXferInfo & setSourceDirection(const bool inTopDown)
Sets the scan direction for the source.
Definition: ntv2publicinterface.h:5999
NTV2CrosspointToString
std::string NTV2CrosspointToString(const NTV2Crosspoint inChannel)
Definition: ntv2utils.cpp:5870
AutoCircVidProcInfo::backgroundVideoCrosspoint
NTV2Crosspoint backgroundVideoCrosspoint
Definition: ntv2publicinterface.h:4315
AUTOCIRCULATE_STATUS_STRUCT::rdtscStartTime
ULWord64 rdtscStartTime
Definition: ntv2publicinterface.h:4425
NTV2Buffer::GetHostAddress
void * GetHostAddress(const ULWord inByteOffset, const bool inFromEnd=false) const
Definition: ntv2publicinterface.cpp:1825
NTV2Buffer::operator=
NTV2Buffer & operator=(const NTV2Buffer &inRHS)
Assigns me from another NTV2Buffer instance.
Definition: ntv2publicinterface.cpp:1695
NTV2ChannelList
std::vector< NTV2Channel > NTV2ChannelList
An ordered sequence of NTV2Channel values.
Definition: ntv2publicinterface.h:3850
NTV2SegmentedDMAInfo::Set
void Set(const ULWord inNumSegments, const ULWord inNumActiveBytesPerRow, const ULWord inHostBytesPerRow, const ULWord inDeviceBytesPerRow)
Sets the NTV2SegmentedDMAInfo struct members.
Definition: ntv2publicinterface.cpp:2724
NTV2Buffer::GetHostPointer
void * GetHostPointer(void) const
Definition: ntv2publicinterface.h:6198
NTV2_FG_1920x1112
@ NTV2_FG_1920x1112
1920x1080, for 1080i and 1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:350
NTV2_INVALID_HDMIBitDepth
@ NTV2_INVALID_HDMIBitDepth
Definition: ntv2enums.h:3668
NTV2InputSource
NTV2InputSource
Identifies a specific video input source.
Definition: ntv2enums.h:1253
NTV2_IS_VALID_HEADER_TAG
#define NTV2_IS_VALID_HEADER_TAG(_x_)
Definition: ntv2publicinterface.h:5566
kVRegMaskHDMOutBitDepth
@ kVRegMaskHDMOutBitDepth
Definition: ntv2virtualregisters.h:646
NTV2SegmentedXferInfo::operator!=
bool operator!=(const NTV2SegmentedXferInfo &inRHS) const
Definition: ntv2publicinterface.cpp:1589
AUTOCIRCULATE_TRANSFER::SegmentedDMAsEnabled
bool SegmentedDMAsEnabled(void) const
Definition: ntv2publicinterface.cpp:2970
NTV2BufferLock::SetMaxLockSize
void SetMaxLockSize(const ULWord64 inNumBytes)
Sets the maximum lock size for use in a subsequent call to CNTV2Card::DMABufferLock.
Definition: ntv2publicinterface.h:8753
NTV2SegmentedXferInfo::setElementLength
NTV2SegmentedXferInfo & setElementLength(const ULWord inBytesPerElement)
Sets my element length.
Definition: ntv2publicinterface.h:6062
kVRegShiftHDMOutVideoStandard
@ kVRegShiftHDMOutVideoStandard
Definition: ntv2virtualregisters.h:663
NTV2Buffer::AsString
std::string AsString(UWord inDumpMaxBytes=0) const
Definition: ntv2publicinterface.cpp:394
NTV2_FORMAT_UNKNOWN
@ NTV2_FORMAT_UNKNOWN
Definition: ntv2enums.h:525
NTV2StreamChannel::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8923
AUTOCIRCULATE_STATUS::acEndFrame
LWord acEndFrame
Last frame to circulate. FIXFIXFIX Why is this signed? CHANGE TO ULWord??
Definition: ntv2publicinterface.h:7326
NTV2BankSelGetSetRegs::mIsWriting
ULWord mIsWriting
If non-zero, register(s) will be written; otherwise, register(s) will be read.
Definition: ntv2publicinterface.h:7784
AUTOCIRCULATE_TRANSFER_STATUS::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4025
FRAME_STAMP::acAudioClockCurrentTime
ULWord64 acAudioClockCurrentTime
The absolute timestamp at the moment the CNTV2Card::AutoCirculateTransfer or CNTV2Card::AutoCirculate...
Definition: ntv2publicinterface.h:7994
AUTOCIRCULATE_WITH_VIDPROC
#define AUTOCIRCULATE_WITH_VIDPROC
Use this to AutoCirculate with video processing.
Definition: ntv2publicinterface.h:5633
AUTOCIRCULATE_STATUS_STRUCT::bWithCustomAncData
BOOL_ bWithCustomAncData
Definition: ntv2publicinterface.h:4438
ntv2nub::PUSHU32
void PUSHU32(const uint32_t inVal, std::vector< uint8_t > &inArr, const bool dontSwap=false)
Definition: ntv2nubtypes.h:38
kVRegMaskHDMOutAudioFormat
@ kVRegMaskHDMOutAudioFormat
Definition: ntv2virtualregisters.h:651
AUTOCIRCULATE_WITH_FBOCHANGE
#define AUTOCIRCULATE_WITH_FBOCHANGE
Use this to AutoCirculate with the possibility of frame buffer orientation changes.
Definition: ntv2publicinterface.h:5631
NTV2SetRegisters::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3802
FRAME_STAMP_STRUCT::currentAudioExpectedAddress
ULWord currentAudioExpectedAddress
As set by play.
Definition: ntv2publicinterface.h:4611
AUTOCIRCULATE_TRANSFER::~AUTOCIRCULATE_TRANSFER
~AUTOCIRCULATE_TRANSFER()
My default destructor, which frees all allocatable fields that I own.
Definition: ntv2publicinterface.cpp:2834
NTV2DIDSetConstIter
NTV2DIDSet::const_iterator NTV2DIDSetConstIter
Handy const iterator to iterate over an NTV2DIDSet.
Definition: ntv2publicinterface.h:78
AUTOCIRCULATE_DATA::lVal6
LWord lVal6
Definition: ntv2publicinterface.h:4484
AutoCircVidProcInfo::foregroundVideoCrosspoint
NTV2Crosspoint foregroundVideoCrosspoint
Definition: ntv2publicinterface.h:4314
NTV2QtrSizeExpandMode
enum NTV2QuarterSizeExpandMode NTV2QtrSizeExpandMode
NTV2_FG_720x598
@ NTV2_FG_720x598
720x576, for PAL 625i, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:349
NTV2_HEADER::FourCCToString
static std::string FourCCToString(const ULWord in4CC)
Definition: ntv2publicinterface.cpp:341
NTV2AudioRate
NTV2AudioRate
Definition: ntv2enums.h:1914
AUTOCIRCULATE_STATUS::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3906
AutoCircVidProcInfo::transitionCoefficient
Fixed_ transitionCoefficient
Definition: ntv2publicinterface.h:4318
NTV2_FBF_10BIT_YCBCR
@ NTV2_FBF_10BIT_YCBCR
See 10-Bit YCbCr Format.
Definition: ntv2enums.h:213
AJA_NTV2_SDK_BUILD_NUMBER
#define AJA_NTV2_SDK_BUILD_NUMBER
The SDK build number, an unsigned decimal integer.
Definition: ntv2version.h:16
FRAME_STAMP::acAudioOutStartAddress
ULWord acAudioOutStartAddress
(output/playback only) Audio play head position (exclusive) AFTER this frame was stamped.
Definition: ntv2publicinterface.h:7957
FRAME_STAMP_STRUCT::currentRP188
RP188_STRUCT currentRP188
Last vertical blank timecode (RP-188)
Definition: ntv2publicinterface.h:4600
AUTOCIRCULATE_TRANSFER::Clear
void Clear(void)
Resets the struct to its initialized state, with timecode capture disabled, freeing all buffers that ...
Definition: ntv2publicinterface.cpp:2943
FRAME_STAMP::FRAME_STAMP
FRAME_STAMP()
Constructs a default FRAME_STAMP structure.
Definition: ntv2publicinterface.cpp:2173
AUTOCIRCULATE_STATUS::WithLTC
bool WithLTC(void) const
Definition: ntv2publicinterface.h:7506
NTV2StreamChannel::mChannel
NTV2Channel mChannel
Stream channel.
Definition: ntv2publicinterface.h:8910
NTV2SDIInStatistics::GetSDIInputStatus
bool GetSDIInputStatus(NTV2SDIInputStatus &outStatus, const UWord inSDIInputIndex0=0)
Answers with the NTV2SDIInputStatus for the given SDI input spigot.
Definition: ntv2publicinterface.cpp:2477
AUTOCIRCULATE_STATUS_STRUCT
Definition: ntv2publicinterface.h:4418
NTV2RegisterNumber
NTV2RegisterNumber
Definition: ntv2publicinterface.h:100
LWord64
int64_t LWord64
Definition: ajatypes.h:257
NTV2StreamBuffer::mChannel
NTV2Channel mChannel
Stream channel.
Definition: ntv2publicinterface.h:8970
NTV2SegmentedDMAInfo::Reset
void Reset(void)
Resets the NTV2SegmentedDMAInfo struct members to their default values (normal, non-segmented AutoCir...
Definition: ntv2publicinterface.cpp:2738
ULWord64SequenceConstIter
ULWord64Sequence::const_iterator ULWord64SequenceConstIter
A handy const iterator for iterating over a ULWord64Sequence.
Definition: ntv2publicinterface.h:51
DEC
#define DEC(__x__)
Definition: ntv2publicinterface.h:5694
NTV2SDIInStatistics
This is used by the CNTV2Card::ReadSDIStatistics function.
Definition: ntv2publicinterface.h:7873
AUTOCIRCULATE_STATUS::acRDTSCStartTime
ULWord64 acRDTSCStartTime
Timestamp of the first VBI received after CNTV2Card::AutoCirculateStart called, using host OS system ...
Definition: ntv2publicinterface.h:7328
AUTOCIRCULATE_STATUS_STRUCT::framesDropped
ULWord framesDropped
Definition: ntv2publicinterface.h:4430
false
#define false
Definition: ntv2devicefeatures.h:25
NTV2HDMIColorSpaceToString
std::string NTV2HDMIColorSpaceToString(const NTV2HDMIColorSpace inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6742
NTV2RegInfo
Everything needed to call CNTV2Card::ReadRegister or CNTV2Card::WriteRegister functions.
Definition: ntv2publicinterface.h:3977
OCT
#define OCT(__x__)
Definition: ntv2publicinterface.h:5697
common.h
Private include file for all ajabase sources.
AUTOCIRCULATE_TRANSFER::acInUserCookie
ULWord64 acInUserCookie
Intended for playout, an optional app-specific cookie value that tags this frame, such that if this s...
Definition: ntv2publicinterface.h:8267
NTV2Buffer_ALLOCATED
#define NTV2Buffer_ALLOCATED
Allocated using Allocate function?
Definition: ntv2publicinterface.h:5613
UByte
uint8_t UByte
Definition: ajatypes.h:250
NTV2AudioSystemSetConstIter
NTV2AudioSystemSet::const_iterator NTV2AudioSystemSetConstIter
A handy const iterator into an NTV2AudioSystemSet. New in SDK 16.2.
Definition: ntv2publicinterface.h:3916
AUTOCIRCULATE_WITH_RP188
#define AUTOCIRCULATE_WITH_RP188
Use this to AutoCirculate with RP188.
Definition: ntv2publicinterface.h:5628
NTV2RegisterWrites
std::vector< NTV2RegInfo > NTV2RegisterWrites
Definition: ntv2publicinterface.h:4069
NTV2Bitstream
This is used for bitstream maintainance. (New in SDK 16.0)
Definition: ntv2publicinterface.h:8785
FRAME_STAMP::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:3969
FRAME_STAMP::SetInputTimecode
bool SetInputTimecode(const NTV2TCIndex inTCNdx, const NTV2_RP188 &inTimecode)
Sets one of my input timecodes.
Definition: ntv2publicinterface.cpp:2310
kVRegMaskHDMOutAudioChannels
@ kVRegMaskHDMOutAudioChannels
Definition: ntv2virtualregisters.h:653
NTV2TCIndexesConstIter
NTV2TCIndexes::const_iterator NTV2TCIndexesConstIter
Definition: ntv2publicinterface.h:7008
NTV2Buffer_TO_ULWORD64
#define NTV2Buffer_TO_ULWORD64(__p__)
Definition: ntv2publicinterface.h:5619
NTV2StreamBuffer::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8985
AUTOCIRCULATE_TRANSFER_STATUS::acAncTransferSize
ULWord acAncTransferSize
Total ancillary data bytes for field 1 transferred (capture only).
Definition: ntv2publicinterface.h:8129
NTV2StreamChannel::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8909
HEX0N
#define HEX0N(__x__, __n__)
Definition: debug.cpp:1175
AUTOCIRCULATE_TRANSFER_STATUS::acState
NTV2AutoCirculateState acState
Current AutoCirculate state after the transfer.
Definition: ntv2publicinterface.h:8121
NTV2RegInfo::registerNumber
ULWord registerNumber
My register number to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:3978
NTV2Buffer::SetFromHexString
bool SetFromHexString(const std::string &inStr)
Replaces my contents from the given hex-encoded string, resizing me if necessary.
Definition: ntv2publicinterface.cpp:1923
NTV2_RP188::IsValid
bool IsValid(void) const
Answers true if I'm valid, or false if I'm not valid.
Definition: ntv2publicinterface.h:6960
FRAME_STAMP_STRUCT::currenthUser
ULWord currenthUser
Contains validCount (Play - reps remaining, Record - drops on frame)
Definition: ntv2publicinterface.h:4620
RP188_STRUCT::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4376
NTV2_TRAILER::NTV2_TRAILER
NTV2_TRAILER()
Constructs a default NTV2_TRAILER having the proper version and tag.
Definition: ntv2publicinterface.cpp:1444
NTV2FrameBufferFormatToString
std::string NTV2FrameBufferFormatToString(const NTV2FrameBufferFormat inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6988
NTV2SetRegisters::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3383
NTV2_HEADER::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me into the given output stream.
Definition: ntv2publicinterface.cpp:326
AUTOCIRCULATE_STATUS::Clear
void Clear(void)
Clears my data.
Definition: ntv2publicinterface.cpp:2606
AutoCircTimeCodeTask
Definition: ntv2publicinterface.h:4810
NTV2SetRegisters::GetRequestedRegisterWrites
bool GetRequestedRegisterWrites(NTV2RegWrites &outRegWrites) const
Definition: ntv2publicinterface.cpp:3368
NTV2_TYPE_AJASTREAMBUFFER
#define NTV2_TYPE_AJASTREAMBUFFER
Identifies NTV2StreamBuffer struct.
Definition: ntv2publicinterface.h:5584
NTV2SDKVersionDecode_Major
#define NTV2SDKVersionDecode_Major
Definition: ntv2publicinterface.h:5491
NTV2DebugLogging::mSharedMemory
NTV2Buffer mSharedMemory
Virtual address of AJADebug shared memory in calling process' context,.
Definition: ntv2publicinterface.h:8647
FRAME_STAMP_STRUCT::audioInStartAddress
ULWord audioInStartAddress
For record - first position in buffer of audio (includes base offset)
Definition: ntv2publicinterface.h:4564
NTV2DeviceCanDoInputSource
bool NTV2DeviceCanDoInputSource(const NTV2DeviceID inDeviceID, const NTV2InputSource inInputSource)
Definition: ntv2devicefeatures.hpp:18228
NTV2TimeCodes
std::map< NTV2TCIndex, NTV2_RP188 > NTV2TimeCodes
A mapping of NTV2TCIndex enum values to NTV2_RP188 structures.
Definition: ntv2publicinterface.h:7004
NTV2_IS_VALID_COLOR_CORRECTION_MODE
#define NTV2_IS_VALID_COLOR_CORRECTION_MODE(__x__)
Definition: ntv2enums.h:2075
NTV2RegInfo::operator<
bool operator<(const NTV2RegInfo &inRHS) const
Definition: ntv2publicinterface.cpp:3409
NTV2SegmentedDMAInfo::acNumSegments
ULWord acNumSegments
Number of segments of size ::AUTOCIRCULATE_TRANSFER::acVideoBuffer.fByteCount to transfer....
Definition: ntv2publicinterface.h:7208
NTV2InputSourceSetConstIter
NTV2InputSourceSet::const_iterator NTV2InputSourceSetConstIter
A handy const iterator for iterating over an NTV2InputSourceSet.
Definition: ntv2publicinterface.h:9023
ULWord64
uint64_t ULWord64
Definition: ajatypes.h:258
std
Definition: json.hpp:5362
AUTOCIRCULATE_TRANSFER::acVidProcInfo
AutoCircVidProcInfo acVidProcInfo
Specifies the mixer/keyer transition to make. Ignored if AUTOCIRCULATE_WITH_VIDPROC option is not set...
Definition: ntv2publicinterface.h:8281
NTV2_RP188
This struct replaces the old RP188_STRUCT.
Definition: ntv2publicinterface.h:6918
AUTOCIRCULATE_TRANSFER::acVideoBuffer
NTV2Buffer acVideoBuffer
The host video buffer. This field is owned by the client application, and thus is responsible for all...
Definition: ntv2publicinterface.h:8216
AUTOCIRCULATE_WITH_HDMIAUX
#define AUTOCIRCULATE_WITH_HDMIAUX
Use this to AutoCirculate with HDMI auxiliary data.
Definition: ntv2publicinterface.h:5637
NTV2DeviceGetSupportedVideoFormats
bool NTV2DeviceGetSupportedVideoFormats(const NTV2DeviceID inDeviceID, NTV2VideoFormatSet &outFormats)
Returns a set of distinct NTV2VideoFormat values supported on the given device.
Definition: ntv2publicinterface.cpp:1270
NTV2StreamBuffer::Print
std::ostream & Print(std::ostream &inOutStream) const
Definition: ntv2publicinterface.cpp:3117
AUTOCIRCULATE_STATUS_STRUCT::bWithRP188
BOOL_ bWithRP188
Definition: ntv2publicinterface.h:4433
NTV2FrameSize::FGHeight
static ULWord FGHeight(const NTV2FrameGeometry fg)
Definition: ntv2publicinterface.cpp:1482
NTV2MakeChannelList
NTV2ChannelList NTV2MakeChannelList(const NTV2Channel inFirstChannel, const UWord inNumChannels)
Definition: ntv2publicinterface.cpp:3540
NTV2RegInfo::registerShift
ULWord registerShift
My register shift value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:3981
NTV2GetRegisters::GetRegisterValues
bool GetRegisterValues(NTV2RegisterValueMap &outValues) const
Returns an NTV2RegisterValueMap built from my mOutGoodRegisters and mOutValues fields.
Definition: ntv2publicinterface.cpp:3244
FRAME_STAMP_STRUCT::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4470
AutoCircVidProcInfo::RPCDecode
bool RPCDecode(const NTV2_RPC_BLOB_TYPE &inBlob, size_t &inOutIndex)
Definition: ntv2publicinterface.cpp:4089
NTV2DeviceGetSupportedFrameRates
bool NTV2DeviceGetSupportedFrameRates(const NTV2DeviceID inDeviceID, NTV2FrameRateSet &outRates)
Returns a set of distinct NTV2FrameRate values supported on the given device.
Definition: ntv2publicinterface.cpp:1411
ePauseAutoCirc
@ ePauseAutoCirc
Definition: ntv2publicinterface.h:4352
NTV2_FRAMERATE_UNKNOWN
@ NTV2_FRAMERATE_UNKNOWN
Represents an unknown or invalid frame rate.
Definition: ntv2enums.h:405
eInitAutoCirc
@ eInitAutoCirc
Definition: ntv2publicinterface.h:4349
ULWordSequence
std::vector< uint32_t > ULWordSequence
An ordered sequence of ULWord (uint32_t) values.
Definition: ntv2publicinterface.h:46
AUTOCIRCULATE_TRANSFER::acInVideoDMAOffset
ULWord acInVideoDMAOffset
Optional byte offset into the device frame buffer. Defaults to zero. If non-zero, should be a multipl...
Definition: ntv2publicinterface.h:8275
NTV2ColorCorrectionData::Clear
void Clear(void)
Frees my private color correction table buffer and resets my mode to "invalid".
Definition: ntv2publicinterface.cpp:2757
AUTOCIRCULATE_STATUS::GetDroppedFrameCount
ULWord GetDroppedFrameCount(void) const
Definition: ntv2publicinterface.h:7372
AUTOCIRCULATE_TRANSFER::SetAllOutputTimeCodes
bool SetAllOutputTimeCodes(const NTV2_RP188 &inTimecode, const bool inIncludeF2=true)
Intended for playout, replaces all elements of my acOutputTimeCodes member with the given timecode va...
Definition: ntv2publicinterface.cpp:2914
AUTOCIRCULATE_STATUS_STRUCT::bWithAudio
BOOL_ bWithAudio
Definition: ntv2publicinterface.h:4432
AUTOCIRCULATE_STATUS::GetStartFrame
uint16_t GetStartFrame(void) const
Definition: ntv2publicinterface.h:7441
NTV2VideoFormat
enum _NTV2VideoFormat NTV2VideoFormat
Identifies a particular video format.
eStopAutoCirc
@ eStopAutoCirc
Definition: ntv2publicinterface.h:4351
NTV2_TCINDEX_DEFAULT
@ NTV2_TCINDEX_DEFAULT
The "default" timecode (mostly used by the AJA "Retail" service and Control Panel)
Definition: ntv2enums.h:3923
AUTOCIRCULATE_STATUS::acAudioSystem
NTV2AudioSystem acAudioSystem
The audio system being used for this channel (NTV2_AUDIOSYSTEM_INVALID if none)
Definition: ntv2publicinterface.h:7336
AUTOCIRCULATE_STATUS::acAudioClockStartTime
ULWord64 acAudioClockStartTime
Timestamp of the first VBI received after CNTV2Card::AutoCirculateStart called, using "64-bit clean" ...
Definition: ntv2publicinterface.h:7329
eGetFrameStampEx2
@ eGetFrameStampEx2
Definition: ntv2publicinterface.h:4362
NTV2_FG_2048x1112
@ NTV2_FG_2048x1112
2048x1080, for 2Kx1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:355
NTV2TimeCodeList
std::vector< NTV2_RP188 > NTV2TimeCodeList
An ordered sequence of zero or more NTV2_RP188 structures. An NTV2TCIndex enum value can be used as a...
Definition: ntv2publicinterface.h:6999
NTV2FrameGeometry
NTV2FrameGeometry
Identifies a particular video frame geometry.
Definition: ntv2enums.h:339
FRAME_STAMP_STRUCT::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
User cookie at last vblank.
Definition: ntv2publicinterface.cpp:4443
ntv2rp188.h
Declares the CRP188 class. See SMPTE RP188 standard for details.
FRAME_STAMP::CopyTo
bool CopyTo(FRAME_STAMP_STRUCT &outOldStruct) const
Copies my fields into the given FRAME_STAMP_STRUCT.
Definition: ntv2publicinterface.cpp:2397
std::swap
void swap(nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass > &j1, nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass > &j2) noexcept(//NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp) is_nothrow_move_constructible< nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass > >::value &&//NOLINT(misc-redundant-expression, cppcoreguidelines-noexcept-swap, performance-noexcept-swap) is_nothrow_move_assignable< nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass > >::value)
exchanges the values of two JSON objects
Definition: json.hpp:24538
FindFirstMatchingRegisterNumber
NTV2RegisterReadsConstIter FindFirstMatchingRegisterNumber(const uint32_t inRegNum, const NTV2RegisterReads &inRegInfos)
Returns a const iterator to the first entry in the NTV2RegInfo collection with a matching register nu...
Definition: ntv2publicinterface.cpp:3596
NTV2_IS_REGISTER_TASK
#define NTV2_IS_REGISTER_TASK(_x_)
Definition: ntv2publicinterface.h:4795
NTV2DeviceIDSet
std::set< NTV2DeviceID > NTV2DeviceIDSet
A set of NTV2DeviceIDs.
Definition: ntv2utils.h:1039
AUTOCIRCULATE_TRANSFER_STATUS::acFramesDropped
ULWord acFramesDropped
Total number of frames dropped since AutoCirculateStart.
Definition: ntv2publicinterface.h:8125
NTV2Bitstream::mBuffer
NTV2Buffer mBuffer
Virtual address of a bitstream buffer and its length.
Definition: ntv2publicinterface.h:8787
AUTOCIRCULATE_STATUS::WithFBFChange
bool WithFBFChange(void) const
Definition: ntv2publicinterface.h:7511
NTV2_OUTPUTDESTINATION_SDI7
@ NTV2_OUTPUTDESTINATION_SDI7
Definition: ntv2enums.h:1320
NTV2Buffer::PutU8s
bool PutU8s(const UByteSequence &inU8s, const size_t inU8Offset=0)
Copies a vector of unsigned 8-bit values into me.
Definition: ntv2publicinterface.cpp:854
AUTOCIRCULATE_STATUS_STRUCT::rdtscCurrentTime
ULWord64 rdtscCurrentTime
Definition: ntv2publicinterface.h:4427
kVRegMaskHDMOutProtocol
@ kVRegMaskHDMOutProtocol
Definition: ntv2virtualregisters.h:650
INVALID_TIMECODE_VALUE
static const NTV2_RP188 INVALID_TIMECODE_VALUE
Definition: ntv2publicinterface.cpp:2875
NTV2SetRegisters
This is used by the CNTV2Card::WriteRegisters function.
Definition: ntv2publicinterface.h:7719
NTV2MakeChannelSet
NTV2ChannelSet NTV2MakeChannelSet(const NTV2Channel inFirstChannel, const UWord inNumChannels)
Definition: ntv2publicinterface.cpp:3523
NTV2_FG_2048x1114
@ NTV2_FG_2048x1114
2048x1080, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:347
AsU8Ref
#define AsU8Ref(_x_)
Definition: ntv2publicinterface.cpp:3686
NTV2SetRegisters::mOutNumFailures
ULWord mOutNumFailures
The number of registers unsuccessfully written.
Definition: ntv2publicinterface.h:7723
NTV2_IS_VALID_NTV2FrameRate
#define NTV2_IS_VALID_NTV2FrameRate(__r__)
Definition: ntv2enums.h:435
NTV2CrosspointToNTV2Channel
NTV2Channel NTV2CrosspointToNTV2Channel(const NTV2Crosspoint inCrosspointChannel)
Definition: ntv2utils.cpp:4773
FRAME_STAMP::acCurrentAudioExpectedAddress
ULWord acCurrentAudioExpectedAddress
Definition: ntv2publicinterface.h:8001
AUTOCIRCULATE_TRANSFER_STATUS::AUTOCIRCULATE_TRANSFER_STATUS
AUTOCIRCULATE_TRANSFER_STATUS()
Constructs a default AUTOCIRCULATE_TRANSFER_STATUS structure.
Definition: ntv2publicinterface.cpp:2515
kVRegMaskHDMOutPixel420
@ kVRegMaskHDMOutPixel420
Definition: ntv2virtualregisters.h:649
ULWord64Sequence
std::vector< uint64_t > ULWord64Sequence
An ordered sequence of ULWord64 (uint64_t) values.
Definition: ntv2publicinterface.h:50
AUTOCIRCULATE_DATA::bVal4
BOOL_ bVal4
Definition: ntv2publicinterface.h:4489
NTV2SDKVersionDecode_Point
#define NTV2SDKVersionDecode_Point
Definition: ntv2publicinterface.h:5493
AUTOCIRCULATE_STATUS_STRUCT::audioClockCurrentTime
ULWord64 audioClockCurrentTime
Definition: ntv2publicinterface.h:4428
NTV2_OUTPUTDESTINATION_SDI4
@ NTV2_OUTPUTDESTINATION_SDI4
Definition: ntv2enums.h:1317
NTV2Buffer_PAGE_ALIGNED
#define NTV2Buffer_PAGE_ALIGNED
Allocated page-aligned?
Definition: ntv2publicinterface.h:5614
FRAME_STAMP::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3933
NTV2_ASSERT_STRUCT_VALID
#define NTV2_ASSERT_STRUCT_VALID
Definition: ntv2publicinterface.h:3960
NTV2RegInfo::registerMask
ULWord registerMask
My register mask value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:3980
FRAME_STAMP_STRUCT::audioClockTimeStamp
ULWord64 audioClockTimeStamp
48kHz clock (in reg 28, extended to 64 bits) at time of play or record.
Definition: ntv2publicinterface.h:4558
NTV2Buffer::Truncate
bool Truncate(const size_t inByteCount)
Truncates me to the given length. No reallocation takes place.
Definition: ntv2publicinterface.cpp:1683
ntv2nubtypes.h
Declares data types and structures used in NTV2 "nub" packets.
NTV2Buffer::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3732
NTV2ColorCorrectionData::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4062
NTV2HDMIOutputStatus::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me into the given output stream.
Definition: ntv2publicinterface.cpp:183
AUTOCIRCULATE_STATUS::WithCustomAnc
bool WithCustomAnc(void) const
Definition: ntv2publicinterface.h:7496
AUTOCIRCULATE_TRANSFER::acOutputTimeCodes
NTV2Buffer acOutputTimeCodes
Intended for playout, this is an ordered sequence of NTV2_RP188 values to send to the device....
Definition: ntv2publicinterface.h:8253
ntv2nub::POPU16
void POPU16(uint16_t &outVal, const std::vector< uint8_t > &inArr, std::size_t &inOutNdx, const bool dontSwap=false)
Definition: ntv2nubtypes.h:61
FRAME_STAMP_STRUCT::audioOutStopAddress
ULWord audioOutStopAddress
For play - first position in buffer of audio.
Definition: ntv2publicinterface.h:4570
eSetActiveFrame
@ eSetActiveFrame
Definition: ntv2publicinterface.h:4364
OCT0N
#define OCT0N(__x__, __n__)
Definition: ntv2publicinterface.h:5698
AJA_NTV2_SDK_VERSION_MINOR
#define AJA_NTV2_SDK_VERSION_MINOR
The SDK minor version number, an unsigned decimal integer.
Definition: ntv2version.h:14
AutoCircVidProcInfo::backgroundKeyCrosspoint
NTV2Crosspoint backgroundKeyCrosspoint
Definition: ntv2publicinterface.h:4317
NTV2AudioChannelPairsConstIter
NTV2AudioChannelPairs::const_iterator NTV2AudioChannelPairsConstIter
Handy const iterator to iterate over a set of distinct NTV2AudioChannelPair values.
Definition: ntv2publicinterface.h:59
NTV2HDMIOutputStatus::SetFromRegValue
bool SetFromRegValue(const ULWord inData)
Sets my fields from the given status register value.
Definition: ntv2publicinterface.cpp:164
NTV2StreamBuffer::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8969
NTV2GetSupportedStandards
bool NTV2GetSupportedStandards(NTV2StandardSet &outStandards)
Returns a set of all NTV2Standard values supported (used) by any/all supported NTV2 devices.
Definition: ntv2publicinterface.cpp:1243
NTV2_FRAMEBUFFER_ORIENTATION_BOTTOMUP
@ NTV2_FRAMEBUFFER_ORIENTATION_BOTTOMUP
Definition: ntv2enums.h:2035
NTV2SDKVersionDecode_Build
#define NTV2SDKVersionDecode_Build
Definition: ntv2publicinterface.h:5494
NTV2_INVALID_HDMI_COLORSPACE
@ NTV2_INVALID_HDMI_COLORSPACE
Definition: ntv2enums.h:3581
AutoCircVidProcInfo::transitionSoftness
Fixed_ transitionSoftness
Definition: ntv2publicinterface.h:4319
NTV2VirtualData
This is used to perform virtual data reads or writes.
Definition: ntv2publicinterface.h:7832
AUTOCIRCULATE_STATUS::WithColorCorrect
bool WithColorCorrect(void) const
Definition: ntv2publicinterface.h:7521
FRAME_STAMP_STRUCT::currentFrameTime
LWord64 currentFrameTime
Vertical blank start of current frame.
Definition: ntv2publicinterface.h:4603
NTV2ChannelToString
std::string NTV2ChannelToString(const NTV2Channel inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5792
NTV2_INPUT_SOURCE_IS_SDI
#define NTV2_INPUT_SOURCE_IS_SDI(_inpSrc_)
Definition: ntv2enums.h:1274
NTV2Buffer::NextDifference
bool NextDifference(const NTV2Buffer &inBuffer, ULWord &byteOffset) const
Answers with the byte offset to the first or next difference.
Definition: ntv2publicinterface.cpp:2040
GetNTV2StandardFromVideoFormat
NTV2Standard GetNTV2StandardFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:2279
NTV2BufferLock::mFlags
ULWord mFlags
Action flags (lock, unlock, etc)
Definition: ntv2publicinterface.h:8685
NTV2Buffer::ByteSwap64
bool ByteSwap64(void)
Byte-swaps my contents 64-bits at a time.
Definition: ntv2publicinterface.cpp:1717
NTV2StreamChannel::mFlags
ULWord mFlags
Action flags.
Definition: ntv2publicinterface.h:8911
AUTOCIRCULATE_TASK_STRUCT
Definition: ntv2publicinterface.h:4861
NTV2BankSelGetSetRegs::mInBankInfos
NTV2Buffer mInBankInfos
Bank select NTV2RegInfo. The SDK owns this memory.
Definition: ntv2publicinterface.h:7785
NTV2Buffer::Fill
bool Fill(const T &inValue)
Fills me with the given scalar value.
Definition: ntv2publicinterface.h:6367
NTV2_FG_7680x4320
@ NTV2_FG_7680x4320
Definition: ntv2enums.h:363
NTV2VirtualData::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:7833
NTV2_HDMIColorSpaceRGB
@ NTV2_HDMIColorSpaceRGB
RGB color space.
Definition: ntv2enums.h:3578
NTV2RegReads
NTV2RegWrites NTV2RegReads
An ordered sequence of zero or more NTV2RegInfo structs intended for ReadRegister.
Definition: ntv2publicinterface.h:4072
AUTOCIRCULATE_DATA::bVal8
BOOL_ bVal8
Definition: ntv2publicinterface.h:4493
NTV2AudioRateToString
std::string NTV2AudioRateToString(const NTV2AudioRate inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5821
kVRegShiftHDMOutPixel420
@ kVRegShiftHDMOutPixel420
Definition: ntv2virtualregisters.h:668
NTV2BufferLock::NTV2BufferLock
NTV2BufferLock()
Constructs a default NTV2BufferLock struct.
Definition: ntv2publicinterface.cpp:3014
NTV2DebugLogging::mTrailer
NTV2_TRAILER mTrailer
The common structure trailer – ALWAYS LAST!
Definition: ntv2publicinterface.h:8652
AUTOCIRCULATE_STATUS::GetFrameCount
ULWord GetFrameCount(void) const
Definition: ntv2publicinterface.h:7367
AUTOCIRCULATE_TRANSFER_STATUS::acAudioTransferSize
ULWord acAudioTransferSize
Number of bytes captured into the audio buffer.
Definition: ntv2publicinterface.h:8127
ntv2publicinterface.h
Declares enums and structs used by all platform drivers and the SDK.
NTV2_TYPE_SETREGS
#define NTV2_TYPE_SETREGS
Identifies NTV2SetRegisters struct.
Definition: ntv2publicinterface.h:5578
NTV2_FG_1280x740
@ NTV2_FG_1280x740
1280x720, for 720p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:351
AUTOCIRCULATE_WITH_COLORCORRECT
#define AUTOCIRCULATE_WITH_COLORCORRECT
Use this to AutoCirculate with color correction.
Definition: ntv2publicinterface.h:5632
AUTOCIRCULATE_STATUS::IsFieldMode
bool IsFieldMode(void) const
Definition: ntv2publicinterface.h:7531
FRAME_STAMP::acFrameTime
LWord64 acFrameTime
(input/ingest/capture only) The absolute timestamp at the VBI when the frame started recording into d...
Definition: ntv2publicinterface.h:7937
AUTOCIRCULATE_TRANSFER::GetInputTimeCodes
bool GetInputTimeCodes(NTV2TimeCodeList &outValues) const
Intended for capture, answers with the timecodes captured in my acTransferStatus member's acFrameStam...
Definition: ntv2publicinterface.cpp:2977
NTV2_AUDIO_FORMAT_INVALID
@ NTV2_AUDIO_FORMAT_INVALID
Definition: ntv2enums.h:1942
NTV2Buffer::HostPageSize
static size_t HostPageSize(void)
Definition: ntv2publicinterface.cpp:2163
NTV2FrameSize::FGWidth
static ULWord FGWidth(const NTV2FrameGeometry fg)
Definition: ntv2publicinterface.cpp:1456
NTV2RegValueMapConstIter
NTV2RegisterValueMap::const_iterator NTV2RegValueMapConstIter
A const iterator that iterates over NTV2RegisterValueMap entries.
Definition: ntv2publicinterface.h:7596
NTV2DebugLogging
This is used to enable or disable AJADebug logging in the driver.
Definition: ntv2publicinterface.h:8645
NTV2_FG_2048x1556
@ NTV2_FG_2048x1556
2048x1556, for 2Kx1556psf film format, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:353
NTV2_TYPE_AJABITSTREAM
#define NTV2_TYPE_AJABITSTREAM
Identifies NTV2Bitstream struct.
Definition: ntv2publicinterface.h:5582
NTV2EndianSwap64
#define NTV2EndianSwap64(__val__)
Definition: ntv2endian.h:25
AUTOCIRCULATE_STATUS::acFramesDropped
ULWord acFramesDropped
Total number of frames dropped since CNTV2Card::AutoCirculateStart called.
Definition: ntv2publicinterface.h:7333
AUTOCIRCULATE_DATA::Print
std::ostream & Print(std::ostream &oss) const
Definition: ntv2publicinterface.cpp:239
NTV2ChannelListConstIter
NTV2ChannelList::const_iterator NTV2ChannelListConstIter
A handy const iterator into an NTV2ChannelList.
Definition: ntv2publicinterface.h:3851
NTV2ColorCorrectionData::NTV2ColorCorrectionData
NTV2ColorCorrectionData()
Constructs a default NTV2ColorCorrectionData struct.
Definition: ntv2publicinterface.cpp:2744
FRAME_STAMP_STRUCT::frame
ULWord frame
The frame requested or -1 if not available.
Definition: ntv2publicinterface.h:4555
NTV2DIDSet
std::set< UByte > NTV2DIDSet
A set of distinct NTV2DID values.
Definition: ntv2publicinterface.h:76
NTV2_TRAILER_TAG
#define NTV2_TRAILER_TAG
Identifies the struct trailer.
Definition: ntv2publicinterface.h:5564
NTV2HostIsBigEndian
#define NTV2HostIsBigEndian
Definition: ntv2endian.h:58
NTV2_IS_VALID_FRAME_BUFFER_FORMAT
#define NTV2_IS_VALID_FRAME_BUFFER_FORMAT(__s__)
Definition: ntv2enums.h:254
AUTOCIRCULATE_DATA::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4501
FRAME_STAMP::acRequestedFrame
ULWord acRequestedFrame
On entry for NTV2_TYPE_ACFRAMESTAMP message, the requested frame. Upon exit, 0xFFFFFFFF means "not ...
Definition: ntv2publicinterface.h:7941
AUTOCIRCULATE_DATA::bVal7
BOOL_ bVal7
Definition: ntv2publicinterface.h:4492
NTV2Buffer::FindAll
ULWordSet & FindAll(ULWordSet &outOffsets, const NTV2Buffer &inValue) const
Definition: ntv2publicinterface.cpp:1969
operator<<
ostream & operator<<(ostream &inOutStr, const NTV2AudioChannelPairs &inSet)
Definition: ntv2publicinterface.cpp:34
kVRegMaskHDMOutRangeFull
@ kVRegMaskHDMOutRangeFull
Definition: ntv2virtualregisters.h:648
NTV2DoubleArrayConstIter
NTV2DoubleArray::const_iterator NTV2DoubleArrayConstIter
Handy const iterator to iterate over an NTV2DoubleArray.
Definition: ntv2publicinterface.h:72
xHEX0N
#define xHEX0N(__x__, __n__)
Definition: ntv2publicinterface.h:5693
NTV2AudioSystem
NTV2AudioSystem
Used to identify an Audio System on an NTV2 device. See Audio System Operation for more information.
Definition: ntv2enums.h:3865
NTV2DebugLogging::mHeader
NTV2_HEADER mHeader
The common structure header – ALWAYS FIRST!
Definition: ntv2publicinterface.h:8646
NTV2Buffer::GetU16s
bool GetU16s(UWordSequence &outU16s, const size_t inU16Offset=0, const size_t inMaxSize=64, const bool inByteSwap=false) const
Answers with my contents as a vector of unsigned 16-bit values.
Definition: ntv2publicinterface.cpp:641
NTV2Bitstream::NTV2Bitstream
NTV2Bitstream()
Constructs a default NTV2Bitstream struct.
Definition: ntv2publicinterface.cpp:3063
NTV2_AUDIO_RATE_INVALID
@ NTV2_AUDIO_RATE_INVALID
Definition: ntv2enums.h:1920
AUTOCIRCVIDPROCMODE_MIX
@ AUTOCIRCVIDPROCMODE_MIX
Definition: ntv2publicinterface.h:4300
NTV2_IS_VALID_AUDIO_SYSTEM
#define NTV2_IS_VALID_AUDIO_SYSTEM(__x__)
Definition: ntv2enums.h:3884
NTV2StreamBuffer
Definition: ntv2publicinterface.h:8968
NTV2StreamBuffer::mStatus
ULWord mStatus
Action status.
Definition: ntv2publicinterface.h:8972
NTV2Bitstream::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:3091
NTV2SDIInStatistics::operator[]
NTV2SDIInputStatus & operator[](const size_t inSDIInputIndex0)
Definition: ntv2publicinterface.cpp:2493
NTV2AudioChannelOctets
std::set< NTV2AudioChannelOctet > NTV2AudioChannelOctets
A set of distinct NTV2AudioChannelOctet values.
Definition: ntv2publicinterface.h:66
NTV2_INPUT_SOURCE_IS_ANALOG
#define NTV2_INPUT_SOURCE_IS_ANALOG(_inpSrc_)
Definition: ntv2enums.h:1273
NTV2RegisterReadsIter
NTV2RegWritesIter NTV2RegisterReadsIter
Definition: ntv2publicinterface.h:4074
ntv2nub::PUSHU16
void PUSHU16(const uint16_t inVal, std::vector< uint8_t > &inArr, const bool dontSwap=false)
Definition: ntv2nubtypes.h:31
NTV2Buffer::SetAndFill
bool SetAndFill(const void *pInUserPointer, const size_t inByteCount, const UByte inValue)
Sets (or resets) me from a client-supplied address and size.
Definition: ntv2publicinterface.cpp:1763
AJAMemory::AllocateAligned
static void * AllocateAligned(size_t size, size_t alignment)
Definition: memory.cpp:115
NTV2FrameRateToString
std::string NTV2FrameRateToString(const NTV2FrameRate inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:7232
ntv2registerexpert.h
Declares the CNTV2RegisterExpert class.
NTV2_FG_1920x1080
@ NTV2_FG_1920x1080
1920x1080, for 1080i and 1080p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:341
NTV2BankSelGetSetRegs::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3843
AUTOCIRCULATE_TRANSFER::acANCBuffer
NTV2Buffer acANCBuffer
The host ancillary data buffer. This field is owned by the client application, and thus is responsibl...
Definition: ntv2publicinterface.h:8234
NTV2FrameRateSet
std::set< NTV2FrameRate > NTV2FrameRateSet
A set of distinct NTV2FrameRate values. New in SDK 17.0.
Definition: ntv2publicinterface.h:9028
NTV2Crosspoint
NTV2Crosspoint
Logically, these are an NTV2Channel combined with an NTV2Mode.
Definition: ntv2enums.h:1686
NTV2IOKinds
ULWord NTV2IOKinds
Definition: ntv2enums.h:1296
AUTOCIRCULATE_TRANSFER_STATUS::acFramesProcessed
ULWord acFramesProcessed
Total number of frames successfully processed since AutoCirculateStart.
Definition: ntv2publicinterface.h:8124
NTV2GetRegisters::PatchRegister
bool PatchRegister(const ULWord inRegNum, const ULWord inValue)
Patches the given register value.
Definition: ntv2publicinterface.cpp:3220
NTV2GetRegisters::ResetUsing
bool ResetUsing(const NTV2RegNumSet &inRegisterNumbers)
Resets me, starting over, now using the given NTV2RegisterNumberSet.
Definition: ntv2publicinterface.cpp:3144
AUTOCIRCULATE_TRANSFER_STATUS::acAudioStartSample
ULWord acAudioStartSample
Starting audio sample (valid for capture only).
Definition: ntv2publicinterface.h:8128
AUTOCIRCULATE_TRANSFER::acPeerToPeerFlags
ULWord acPeerToPeerFlags
Definition: ntv2publicinterface.h:8290
memory.h
Declares the AJAMemory class.
NTV2PrintAudioSystemSet
ostream & NTV2PrintAudioSystemSet(const NTV2AudioSystemSet &inObj, const bool inCompact, std::ostream &inOutStream)
Streams a human-readable dump of the given NTV2AudioSystemSet into the specified output stream.
Definition: ntv2publicinterface.cpp:3557
kVRegShiftHDMOutAudioChannels
@ kVRegShiftHDMOutAudioChannels
Definition: ntv2virtualregisters.h:672
FRAME_STAMP_STRUCT::currentFieldCount
ULWord currentFieldCount
At Call Field0 or Field1 currently being OUTPUT (at the time of the IOCTL_NTV2_GET_FRAMESTAMP)
Definition: ntv2publicinterface.h:4617
NTV2_TYPE_AJASTREAMCHANNEL
#define NTV2_TYPE_AJASTREAMCHANNEL
Identifies NTV2StreamChannel struct.
Definition: ntv2publicinterface.h:5583
NTV2RegInfo::PrintCode
std::ostream & PrintCode(std::ostream &outputStream, const int inRadix=16, const NTV2DeviceID inDeviceID=DEVICE_ID_INVALID) const
Renders me to the given output stream as source code using a "WriteRegister" function call.
Definition: ntv2publicinterface.cpp:3431
NTV2_IS_TIMECODE_TASK
#define NTV2_IS_TIMECODE_TASK(_x_)
Definition: ntv2publicinterface.h:4799
NTV2SegmentedXferInfo::getSourceCode
std::string getSourceCode(const bool inInclDecl=true) const
Definition: ntv2publicinterface.cpp:1536
NTV2_AUTOCIRCULATE_STARTING_AT_TIME
@ NTV2_AUTOCIRCULATE_STARTING_AT_TIME
The AutoCirculate channel is starting, waiting for the start time specified in the call to CNTV2Card:...
Definition: ntv2publicinterface.h:4383
AUTOCIRCULATE_TRANSFER::SetBuffers
bool SetBuffers(ULWord *pInVideoBuffer, const ULWord inVideoByteCount, ULWord *pInAudioBuffer, const ULWord inAudioByteCount, ULWord *pInANCBuffer, const ULWord inANCByteCount, ULWord *pInANCF2Buffer=NULL, const ULWord inANCF2ByteCount=0)
Sets my buffers for use in a subsequent call to CNTV2Card::AutoCirculateTransfer.
Definition: ntv2publicinterface.cpp:2839
CNTV2RegisterExpert::GetDisplayValue
static std::string GetDisplayValue(const uint32_t inRegNum, const uint32_t inRegValue, const NTV2DeviceID inDeviceID=DEVICE_ID_NOTFOUND)
Definition: ntv2registerexpert.cpp:4668
NTV2FBOrientation
enum NTV2VideoFrameBufferOrientation NTV2FBOrientation
NTV2SDIInStatistics::Print
std::ostream & Print(std::ostream &inOutStream) const
Prints a human-readable representation of me to the given output stream.
Definition: ntv2publicinterface.cpp:2508
NTV2GetSupportedPixelFormats
bool NTV2GetSupportedPixelFormats(NTV2PixelFormats &outFormats)
Returns a set of all NTV2PixelFormat values supported (used) by any/all supported NTV2 devices.
Definition: ntv2publicinterface.cpp:1218
NTV2_IS_VALID_VIDEO_FORMAT
#define NTV2_IS_VALID_VIDEO_FORMAT(__f__)
Definition: ntv2enums.h:716
NTV2_OUTPUTDESTINATION_SDI5
@ NTV2_OUTPUTDESTINATION_SDI5
Definition: ntv2enums.h:1318
debug.h
Declares the AJADebug class.
FRAME_STAMP::acCurrentReps
ULWord acCurrentReps
Contains validCount (Playout: on repeated frames, number of reps remaining; Record: drops on frame)
Definition: ntv2publicinterface.h:8005
NTV2RegInfo::regNum
ULWord regNum(void) const
Definition: ntv2publicinterface.h:4055
AUTOCIRCULATE_TASK_STRUCT::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:4393
NTV2ColorCorrectionData::ccLookupTables
NTV2Buffer ccLookupTables
RGB lookup tables pre-formatted for AJA hardware as a contiguous block of NTV2_COLORCORRECTOR_TABLESI...
Definition: ntv2publicinterface.h:7274
ntv2nub::PUSHU8
void PUSHU8(const uint8_t inVal, std::vector< uint8_t > &inArr)
Definition: ntv2nubtypes.h:26
NTV2SegmentedXferInfo::containsElementAtOffset
bool containsElementAtOffset(const ULWord inElementOffset) const
Definition: ntv2publicinterface.cpp:1566
AUTOCIRCULATE_STATUS_STRUCT::bufferLevel
ULWord bufferLevel
Definition: ntv2publicinterface.h:4431
AUTOCIRCULATE_TRANSFER::AUTOCIRCULATE_TRANSFER
AUTOCIRCULATE_TRANSFER()
Constructs a default AUTOCIRCULATE_TRANSFER struct.
Definition: ntv2publicinterface.cpp:2780
AUTOCIRCULATE_TRANSFER::acRP188
NTV2_RP188 acRP188
Will be deprecated – use AUTOCIRCULATE_TRANSFER::SetOutputTimeCode instead.
Definition: ntv2publicinterface.h:8293
NTV2Buffer::SwapWith
bool SwapWith(NTV2Buffer &inBuffer)
Swaps my underlying buffer with another's.
Definition: ntv2publicinterface.cpp:1950
NTV2Buffer::Set
bool Set(const void *pInUserPointer, const size_t inByteCount)
Sets (or resets) me from a client-supplied address and size.
Definition: ntv2publicinterface.cpp:1753
NTV2_AUTOCIRCULATE_DISABLED
@ NTV2_AUTOCIRCULATE_DISABLED
The AutoCirculate channel is stopped.
Definition: ntv2publicinterface.h:4377
FRAME_STAMP_STRUCT::audioInStopAddress
ULWord audioInStopAddress
For record - end position (exclusive) in buffer of audio (includes base offset)
Definition: ntv2publicinterface.h:4567
Fixed_
int Fixed_
Definition: ajatypes.h:321
NTV2StreamBuffer::mFlags
ULWord mFlags
Action flags.
Definition: ntv2publicinterface.h:8971
AUTOCIRCULATE_STATUS::CopyTo
bool CopyTo(AUTOCIRCULATE_STATUS_STRUCT &outOldStruct)
Copies my data into the given AUTOCIRCULATE_STATUS_STRUCT.
Definition: ntv2publicinterface.cpp:2554
AUTOCIRCULATE_STATUS::IsOutput
bool IsOutput(void) const
Definition: ntv2publicinterface.h:7546
NTV2_OUTPUTDESTINATION_ANALOG1
@ NTV2_OUTPUTDESTINATION_ANALOG1
Definition: ntv2enums.h:1312
AJA_DebugStat_ACXferRPCEncode
@ AJA_DebugStat_ACXferRPCEncode
Definition: debugshare.h:248
NTV2MakeAudioSystemSet
NTV2AudioSystemSet NTV2MakeAudioSystemSet(const NTV2AudioSystem inFirstAudioSystem, const UWord inCount)
Definition: ntv2publicinterface.cpp:3578
NTV2GetRegisters::RPCEncode
bool RPCEncode(NTV2_RPC_BLOB_TYPE &outBlob)
Definition: ntv2publicinterface.cpp:3755
NTV2AudioSystemToString
std::string NTV2AudioSystemToString(const NTV2AudioSystem inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:5810
AutoCircTaskType
AutoCircTaskType
These are the available AutoCirculate task types.
Definition: ntv2publicinterface.h:4780
GetTCIndexesForSDIInput
#define GetTCIndexesForSDIInput
Definition: ntv2utils.h:593
NTV2_TRAILER::fTrailerTag
ULWord fTrailerTag
A special FourCC to identify the tail end of an NTV2 structure.
Definition: ntv2publicinterface.h:7169
NTV2_FBF_LAST
@ NTV2_FBF_LAST
Definition: ntv2enums.h:246
NTV2OutputDestinationToString
std::string NTV2OutputDestinationToString(const NTV2OutputDestination inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:7286
NTV2_AUDIOSYSTEM_INVALID
@ NTV2_AUDIOSYSTEM_INVALID
Definition: ntv2enums.h:3877
NTV2HDMIBitDepthToString
std::string NTV2HDMIBitDepthToString(const NTV2HDMIBitDepth inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6697
NTV2_HEADER::NTV2_HEADER
NTV2_HEADER(const ULWord inStructureType, const ULWord inSizeInBytes)
Constructs a default NTV2_HEADER having the proper tag, version, and the given type and size.
Definition: ntv2publicinterface.cpp:307