AJA NTV2 SDK  17.6.0.2675
NTV2 SDK 17.6.0.2675
ntv2register.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: MIT */
8 #include "ntv2card.h"
9 #include "ntv2devicefeatures.h"
10 #include "ntv2utils.h"
11 #include "ntv2registerexpert.h"
12 #include "ntv2endian.h"
13 #include "ntv2registersmb.h"
14 #include "ntv2konaflashprogram.h"
15 #include "ntv2konaflashprogram.h"
16 #include "ntv2vpid.h"
17 #include "ajabase/system/debug.h"
18 #include <math.h>
19 #include <assert.h>
20 #if defined (MSWindows)
21  #pragma warning(disable: 4800)
22 #endif
23 
24 #define HEX16(__x__) "0x" << hex << setw(16) << setfill('0') << uint64_t(__x__) << dec
25 #define INSTP(_p_) HEX16(uint64_t(_p_))
26 #define CVIDFAIL(__x__) AJA_sERROR (AJA_DebugUnit_VideoGeneric, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
27 #define CVIDWARN(__x__) AJA_sWARNING(AJA_DebugUnit_VideoGeneric, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
28 #define CVIDNOTE(__x__) AJA_sNOTICE (AJA_DebugUnit_VideoGeneric, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
29 #define CVIDINFO(__x__) AJA_sINFO (AJA_DebugUnit_VideoGeneric, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
30 #define CVIDDBG(__x__) AJA_sDEBUG (AJA_DebugUnit_VideoGeneric, INSTP(this) << "::" << AJAFUNC << ": " << __x__)
31 
32 using namespace std;
33 
34 // Indexes into array
35 #define NOMINAL_H 0
36 #define MIN_H 1
37 #define MAX_H 2
38 #define NOMINAL_V 3
39 #define MIN_V 4
40 #define MAX_V 5
41 
42 
43 // Timing constants for K2 and KLS boards
44 #define K2_NOMINAL_H 0x1000
45 #define K2_MIN_H (K2_NOMINAL_H-0x800)
46 #define K2_MAX_H (K2_NOMINAL_H+0x800)
47 #define K2_NOMINAL_V 0x0800
48 #define K2_MIN_V (K2_NOMINAL_V-0x400)
49 #define K2_MAX_V (K2_NOMINAL_V+0x400)
50 
51 #define KLS_NOMINAL_525_H 0x0640
52 #define KLS_MIN_525_H 0x0000
53 #define KLS_MAX_525_H 0x06B3
54 #define KLS_NOMINAL_525_V 0x010A
55 #define KLS_MIN_525_V 0x0001
56 #define KLS_MAX_525_V 0x020D
57 
58 #define KLS_NOMINAL_625_H 0x0638
59 #define KLS_MIN_625_H 0x0000
60 #define KLS_MAX_625_H 0x06BF
61 #define KLS_NOMINAL_625_V 0x0139
62 #define KLS_MIN_625_V 0x0001
63 #define KLS_MAX_625_V 0x0271
64 
65 
66 // These static tables eliminate a lot of switch statements.
67 // CAUTION: These are predicated on NTV2Channel being ordinal (NTV2_CHANNEL1==0, NTV2_CHANNEL2==1, etc.)
68 static const ULWord gChannelToGlobalControlRegNum [] = { kRegGlobalControl, kRegGlobalControlCh2, kRegGlobalControlCh3, kRegGlobalControlCh4,
69  kRegGlobalControlCh5, kRegGlobalControlCh6, kRegGlobalControlCh7, kRegGlobalControlCh8, 0};
70 
71 static const ULWord gChannelToSDIOutControlRegNum [] = { kRegSDIOut1Control, kRegSDIOut2Control, kRegSDIOut3Control, kRegSDIOut4Control,
72  kRegSDIOut5Control, kRegSDIOut6Control, kRegSDIOut7Control, kRegSDIOut8Control, 0};
73 
74 static const ULWord gChannelToControlRegNum [] = { kRegCh1Control, kRegCh2Control, kRegCh3Control, kRegCh4Control, kRegCh5Control, kRegCh6Control,
75  kRegCh7Control, kRegCh8Control, 0};
76 
77 static const ULWord gChannelToOutputFrameRegNum [] = { kRegCh1OutputFrame, kRegCh2OutputFrame, kRegCh3OutputFrame, kRegCh4OutputFrame,
78  kRegCh5OutputFrame, kRegCh6OutputFrame, kRegCh7OutputFrame, kRegCh8OutputFrame, 0};
79 
80 static const ULWord gChannelToInputFrameRegNum [] = { kRegCh1InputFrame, kRegCh2InputFrame, kRegCh3InputFrame, kRegCh4InputFrame,
81  kRegCh5InputFrame, kRegCh6InputFrame, kRegCh7InputFrame, kRegCh8InputFrame, 0};
82 #if !defined(NTV2_DEPRECATE_16_2)
83 static const ULWord gChannelToPCIAccessFrameRegNum [] = { kRegCh1PCIAccessFrame, kRegCh2PCIAccessFrame, kRegCh3PCIAccessFrame, kRegCh4PCIAccessFrame,
84  kRegCh5PCIAccessFrame, kRegCh6PCIAccessFrame, kRegCh7PCIAccessFrame, kRegCh8PCIAccessFrame, 0};
85 #endif // !defined(NTV2_DEPRECATE_16_2)
86 static const ULWord gChannelToRS422ControlRegNum [] = { kRegRS422Control, kRegRS4222Control, 0};
87 
88 static const ULWord gChannelToOutputTimingCtrlRegNum [] = { kRegOutputTimingControl, kRegOutputTimingControlch2, kRegOutputTimingControlch3, kRegOutputTimingControlch4,
89  kRegOutputTimingControlch5, kRegOutputTimingControlch6, kRegOutputTimingControlch7, kRegOutputTimingControlch8, 0};
90 
91 static const ULWord gChannelToSDIInput3GStatusRegNum [] = { kRegSDIInput3GStatus, kRegSDIInput3GStatus, kRegSDIInput3GStatus2, kRegSDIInput3GStatus2,
92  kRegSDI5678Input3GStatus, kRegSDI5678Input3GStatus, kRegSDI5678Input3GStatus, kRegSDI5678Input3GStatus, 0};
93 
94 static const ULWord gChannelToSDIIn3GbModeMask [] = { kRegMaskSDIIn3GbpsSMPTELevelBMode, kRegMaskSDIIn23GbpsSMPTELevelBMode, kRegMaskSDIIn33GbpsSMPTELevelBMode, kRegMaskSDIIn43GbpsSMPTELevelBMode,
95  kRegMaskSDIIn53GbpsSMPTELevelBMode, kRegMaskSDIIn63GbpsSMPTELevelBMode, kRegMaskSDIIn73GbpsSMPTELevelBMode, kRegMaskSDIIn83GbpsSMPTELevelBMode, 0};
96 
97 static const ULWord gChannelToSDIIn3GbModeShift [] = { kRegShiftSDIIn3GbpsSMPTELevelBMode, kRegShiftSDIIn23GbpsSMPTELevelBMode, kRegShiftSDIIn33GbpsSMPTELevelBMode, kRegShiftSDIIn43GbpsSMPTELevelBMode,
98  kRegShiftSDIIn53GbpsSMPTELevelBMode, kRegShiftSDIIn63GbpsSMPTELevelBMode, kRegShiftSDIIn73GbpsSMPTELevelBMode, kRegShiftSDIIn83GbpsSMPTELevelBMode, 0};
99 
100 static const ULWord gIndexToVidProcControlRegNum [] = { kRegVidProc1Control, kRegVidProc2Control, kRegVidProc3Control, kRegVidProc4Control, 0};
101 
102 static const ULWord gIndexToVidProcMixCoeffRegNum [] = { kRegMixer1Coefficient, kRegMixer2Coefficient, kRegMixer3Coefficient, kRegMixer4Coefficient, 0};
103 
104 #if defined (NTV2_ALLOW_2MB_FRAMES)
105 static const ULWord gChannelTo2MFrame [] = { kRegCh1Control2MFrame, kRegCh2Control2MFrame, kRegCh3Control2MFrame, kRegCh4Control2MFrame, kRegCh5Control2MFrame, kRegCh6Control2MFrame,
106  kRegCh7Control2MFrame, kRegCh8Control2MFrame, 0};
107 #endif // defined (NTV2_ALLOW_2MB_FRAMES)
108 
109 static const ULWord gChannelToRP188ModeGCRegisterNum[] = { kRegGlobalControl, kRegGlobalControl, kRegGlobalControl2, kRegGlobalControl2,
110  kRegGlobalControl2, kRegGlobalControl2, kRegGlobalControl2, kRegGlobalControl2, 0};
111 static const ULWord gChannelToRP188ModeMasks[] = { kRegMaskRP188ModeCh1, kRegMaskRP188ModeCh2, kRegMaskRP188ModeCh3, kRegMaskRP188ModeCh4,
112  kRegMaskRP188ModeCh5, ULWord(kRegMaskRP188ModeCh6), kRegMaskRP188ModeCh7, kRegMaskRP188ModeCh8, 0};
113 static const ULWord gChannelToRP188ModeShifts[] = { kRegShiftRP188ModeCh1, kRegShiftRP188ModeCh2, kRegShiftRP188ModeCh3, kRegShiftRP188ModeCh4,
114  kRegShiftRP188ModeCh5, kRegShiftRP188ModeCh6, kRegShiftRP188ModeCh7, kRegShiftRP188ModeCh8, 0};
115 static const ULWord gChlToRP188DBBRegNum[] = { kRegRP188InOut1DBB, kRegRP188InOut2DBB, kRegRP188InOut3DBB, kRegRP188InOut4DBB,
116  kRegRP188InOut5DBB, kRegRP188InOut6DBB, kRegRP188InOut7DBB, kRegRP188InOut8DBB, 0};
117 static const ULWord gChlToRP188Bits031RegNum[] = { kRegRP188InOut1Bits0_31, kRegRP188InOut2Bits0_31, kRegRP188InOut3Bits0_31, kRegRP188InOut4Bits0_31,
118  kRegRP188InOut5Bits0_31, kRegRP188InOut6Bits0_31, kRegRP188InOut7Bits0_31, kRegRP188InOut8Bits0_31, 0};
119 static const ULWord gChlToRP188Bits3263RegNum[] = { kRegRP188InOut1Bits32_63, kRegRP188InOut2Bits32_63, kRegRP188InOut3Bits32_63, kRegRP188InOut4Bits32_63,
120  kRegRP188InOut5Bits32_63, kRegRP188InOut6Bits32_63, kRegRP188InOut7Bits32_63, kRegRP188InOut8Bits32_63, 0};
121 
122 static const ULWord gChannelToRXSDIStatusRegs [] = { kRegRXSDI1Status, kRegRXSDI2Status, kRegRXSDI3Status, kRegRXSDI4Status, kRegRXSDI5Status, kRegRXSDI6Status, kRegRXSDI7Status, kRegRXSDI8Status, 0};
123 
124 static const ULWord gChannelToRXSDICRCErrorCountRegs[] = { kRegRXSDI1CRCErrorCount, kRegRXSDI2CRCErrorCount, kRegRXSDI3CRCErrorCount, kRegRXSDI4CRCErrorCount, kRegRXSDI5CRCErrorCount, kRegRXSDI6CRCErrorCount, kRegRXSDI7CRCErrorCount, kRegRXSDI8CRCErrorCount, 0 };
125 
126 static const ULWord gChannelToSmpte372RegisterNum [] = { kRegGlobalControl, kRegGlobalControl, kRegGlobalControl2, kRegGlobalControl2,
127  kRegGlobalControl2, kRegGlobalControl2, kRegGlobalControl2, kRegGlobalControl2, 0};
128 static const ULWord gChannelToSmpte372Masks [] = { kRegMaskSmpte372Enable, kRegMaskSmpte372Enable, kRegMaskSmpte372Enable4, kRegMaskSmpte372Enable4,
129  kRegMaskSmpte372Enable6, kRegMaskSmpte372Enable6, kRegMaskSmpte372Enable8, kRegMaskSmpte372Enable8, 0};
130 static const ULWord gChannelToSmpte372Shifts [] = { kRegShiftSmpte372, kRegShiftSmpte372, kRegShiftSmpte372Enable4, kRegShiftSmpte372Enable4,
131  kRegShiftSmpte372Enable6, kRegShiftSmpte372Enable6, kRegShiftSmpte372Enable8, kRegShiftSmpte372Enable8, 0};
132 static const ULWord gChannelToSDIIn3GModeMask [] = { kRegMaskSDIIn3GbpsMode, kRegMaskSDIIn23GbpsMode, kRegMaskSDIIn33GbpsMode, kRegMaskSDIIn43GbpsMode,
133  kRegMaskSDIIn53GbpsMode, kRegMaskSDIIn63GbpsMode, kRegMaskSDIIn73GbpsMode, kRegMaskSDIIn83GbpsMode, 0};
134 
135 static const ULWord gChannelToSDIIn3GModeShift [] = { kRegShiftSDIIn3GbpsMode, kRegShiftSDIIn23GbpsMode, kRegShiftSDIIn33GbpsMode, kRegShiftSDIIn43GbpsMode,
136  kRegShiftSDIIn53GbpsMode, kRegShiftSDIIn63GbpsMode, kRegShiftSDIIn73GbpsMode, kRegShiftSDIIn83GbpsMode, 0};
137 static const ULWord gChannelToSDIIn6GModeMask [] = { kRegMaskSDIIn16GbpsMode, kRegMaskSDIIn26GbpsMode, kRegMaskSDIIn36GbpsMode, kRegMaskSDIIn46GbpsMode,
138  kRegMaskSDIIn56GbpsMode, kRegMaskSDIIn66GbpsMode, kRegMaskSDIIn76GbpsMode, kRegMaskSDIIn86GbpsMode, 0};
139 
140 static const ULWord gChannelToSDIIn6GModeShift [] = { kRegShiftSDIIn16GbpsMode, kRegShiftSDIIn26GbpsMode, kRegShiftSDIIn36GbpsMode, kRegShiftSDIIn46GbpsMode,
141  kRegShiftSDIIn56GbpsMode, kRegShiftSDIIn66GbpsMode, kRegShiftSDIIn76GbpsMode, kRegShiftSDIIn86GbpsMode, 0};
142 
143 static const ULWord gChannelToSDIIn12GModeMask [] = { kRegMaskSDIIn112GbpsMode, kRegMaskSDIIn212GbpsMode, kRegMaskSDIIn312GbpsMode, kRegMaskSDIIn412GbpsMode,
144  kRegMaskSDIIn512GbpsMode, kRegMaskSDIIn612GbpsMode, kRegMaskSDIIn712GbpsMode, ULWord(kRegMaskSDIIn812GbpsMode), 0};
145 
146 static const ULWord gChannelToSDIIn12GModeShift [] = { kRegShiftSDIIn112GbpsMode, kRegShiftSDIIn212GbpsMode, kRegShiftSDIIn312GbpsMode, kRegShiftSDIIn412GbpsMode,
147  kRegShiftSDIIn512GbpsMode, kRegShiftSDIIn612GbpsMode, kRegShiftSDIIn712GbpsMode, kRegShiftSDIIn812GbpsMode, 0};
148 
149 static const ULWord gChannelToSDIInputStatusRegNum [] = { kRegInputStatus, kRegInputStatus, kRegInputStatus2, kRegInputStatus2,
150  kRegInput56Status, kRegInput56Status, kRegInput78Status, kRegInput78Status, 0};
151 
152 static const ULWord gChannelToSDIInputRateMask [] = { kRegMaskInput1FrameRate, kRegMaskInput2FrameRate, kRegMaskInput1FrameRate, kRegMaskInput2FrameRate,
153  kRegMaskInput1FrameRate, kRegMaskInput2FrameRate, kRegMaskInput1FrameRate, kRegMaskInput2FrameRate, 0};
154 static const ULWord gChannelToSDIInputRateHighMask [] = { kRegMaskInput1FrameRateHigh, kRegMaskInput2FrameRateHigh, kRegMaskInput1FrameRateHigh, kRegMaskInput2FrameRateHigh,
155  kRegMaskInput1FrameRateHigh, kRegMaskInput2FrameRateHigh, kRegMaskInput1FrameRateHigh, kRegMaskInput2FrameRateHigh, 0};
156 static const ULWord gChannelToSDIInputRateShift [] = { kRegShiftInput1FrameRate, kRegShiftInput2FrameRate, kRegShiftInput1FrameRate, kRegShiftInput2FrameRate,
157  kRegShiftInput1FrameRate, kRegShiftInput2FrameRate, kRegShiftInput1FrameRate, kRegShiftInput2FrameRate, 0};
158 static const ULWord gChannelToSDIInputRateHighShift [] = { kRegShiftInput1FrameRateHigh, kRegShiftInput2FrameRateHigh, kRegShiftInput1FrameRateHigh, kRegShiftInput2FrameRateHigh,
159  kRegShiftInput1FrameRateHigh, kRegShiftInput2FrameRateHigh, kRegShiftInput1FrameRateHigh, kRegShiftInput2FrameRateHigh, 0};
160 
161 static const ULWord gChannelToSDIInputGeometryMask [] = { kRegMaskInput1Geometry, kRegMaskInput2Geometry, kRegMaskInput1Geometry, kRegMaskInput2Geometry,
162  kRegMaskInput1Geometry, kRegMaskInput2Geometry, kRegMaskInput1Geometry, kRegMaskInput2Geometry, 0};
163 static const ULWord gChannelToSDIInputGeometryHighMask [] = { kRegMaskInput1GeometryHigh, ULWord(kRegMaskInput2GeometryHigh), kRegMaskInput1GeometryHigh, ULWord(kRegMaskInput2GeometryHigh),
164  kRegMaskInput1GeometryHigh, ULWord(kRegMaskInput2GeometryHigh), kRegMaskInput1GeometryHigh, ULWord(kRegMaskInput2GeometryHigh), 0};
165 static const ULWord gChannelToSDIInputGeometryShift [] = { kRegShiftInput1Geometry, kRegShiftInput2Geometry, kRegShiftInput1Geometry, kRegShiftInput2Geometry,
166  kRegShiftInput1Geometry, kRegShiftInput2Geometry, kRegShiftInput1Geometry, kRegShiftInput2Geometry, 0};
167 static const ULWord gChannelToSDIInputGeometryHighShift [] = { kRegShiftInput1GeometryHigh, kRegShiftInput2GeometryHigh, kRegShiftInput1GeometryHigh, kRegShiftInput2GeometryHigh,
168  kRegShiftInput1GeometryHigh, kRegShiftInput2GeometryHigh, kRegShiftInput1GeometryHigh, kRegShiftInput2GeometryHigh, 0};
169 
170 static const ULWord gChannelToSDIInputProgressiveMask [] = { kRegMaskInput1Progressive, kRegMaskInput2Progressive, kRegMaskInput1Progressive, kRegMaskInput2Progressive,
171  kRegMaskInput1Progressive, kRegMaskInput2Progressive, kRegMaskInput1Progressive, kRegMaskInput2Progressive, 0};
172 static const ULWord gChannelToSDIInputProgressiveShift [] = { kRegShiftInput1Progressive, kRegShiftInput2Progressive, kRegShiftInput1Progressive, kRegShiftInput2Progressive,
173  kRegShiftInput1Progressive, kRegShiftInput2Progressive, kRegShiftInput1Progressive, kRegShiftInput2Progressive, 0};
174 
175 
176 // Method: SetEveryFrameServices
177 // Input: NTV2EveryFrameTaskMode
178 // Output: NONE
179 bool CNTV2Card::SetEveryFrameServices (NTV2EveryFrameTaskMode mode)
180 {
181  return WriteRegister(kVRegEveryFrameTaskFilter, ULWord(mode));
182 }
183 
184 bool CNTV2Card::GetEveryFrameServices (NTV2EveryFrameTaskMode & outMode)
185 {
186  return CNTV2DriverInterface::ReadRegister(kVRegEveryFrameTaskFilter, outMode);
187 }
188 
189 #if !defined(NTV2_DEPRECATE_16_3)
190  bool CNTV2Card::SetDefaultVideoOutMode(ULWord mode)
191  {
192  return WriteRegister(kVRegDefaultVideoOutMode, mode);
193  }
194 
195  bool CNTV2Card::GetDefaultVideoOutMode(ULWord & outMode)
196  {
197  return ReadRegister (kVRegDefaultVideoOutMode, outMode);
198  }
199 #endif // !defined(NTV2_DEPRECATE_16_3)
200 
201 // Method: SetVideoFormat
202 // Input: NTV2VideoFormat
203 // Output: NONE
204 bool CNTV2Card::SetVideoFormat (const NTV2VideoFormat value, const bool inIsRetail, const bool keepVancSettings, const NTV2Channel inChannel)
205 { AJA_UNUSED(keepVancSettings)
206  bool ajaRetail(inIsRetail);
207 #ifdef MSWindows
208  NTV2EveryFrameTaskMode mode;
209  GetEveryFrameServices(mode);
210  if(mode == NTV2_STANDARD_TASKS)
211  ajaRetail = true;
212 #endif
213  const NTV2Channel channel(IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
214  int hOffset(0), vOffset(0);
215 
216  if (ajaRetail)
217  { // Get the current H and V timing offsets
218  GetVideoHOffset(hOffset);
219  GetVideoVOffset(vOffset);
220  }
221 
222  if (NTV2_IS_TSI_FORMAT(value))
223  { const ULWordSet itms (GetSupportedItems(kNTV2EnumsID_VideoFormat));
224  if (itms.find(ULWord(value)) == itms.end())
225  return false;
226  }
227 
228  NTV2Standard inStandard = GetNTV2StandardFromVideoFormat(value);
229  if(inStandard == NTV2_STANDARD_2Kx1080p && NTV2_IS_PSF_VIDEO_FORMAT(value))
230  {
231  inStandard = NTV2_STANDARD_2Kx1080i;
232  }
233  else if(inStandard == NTV2_STANDARD_3840x2160p && NTV2_IS_PSF_VIDEO_FORMAT(value))
234  {
235  inStandard = NTV2_STANDARD_3840i;
236  }
237  else if(inStandard == NTV2_STANDARD_4096x2160p && NTV2_IS_PSF_VIDEO_FORMAT(value))
238  {
239  inStandard = NTV2_STANDARD_4096i;
240  }
241  NTV2FrameRate inFrameRate = GetNTV2FrameRateFromVideoFormat(value);
242  NTV2FrameGeometry inFrameGeometry = GetNTV2FrameGeometryFromVideoFormat(value);
243  bool squares;
244 
245  // Set the standard for this video format
246  SetStandard(inStandard, channel);
247 
248  // Set the framegeometry for this video format
249  SetFrameGeometry(inFrameGeometry, ajaRetail, channel);
250 
251  // Set the framerate for this video format
252  SetFrameRate(inFrameRate, channel);
253 
254  // Set SMPTE 372 1080p60 Dual Link option
255  SetSmpte372(NTV2_IS_3Gb_FORMAT(value), channel);
256 
257  // set virtual video format
258  WriteRegister (kVRegVideoFormatCh1 + channel, value);
259 
260  //This will handle 4k formats
261  if (NTV2_IS_QUAD_FRAME_FORMAT(value))
262  {
263  SetQuadQuadFrameEnable(false, channel);
264  Get4kSquaresEnable(squares, channel);
265  if (squares)
266  {
267  Set4kSquaresEnable(true, channel);
268  }
269  else
270  {
271  SetQuadFrameEnable(true, channel);
272  }
273  }
274  else if (NTV2_IS_QUAD_QUAD_FORMAT(value))
275  {
276  GetQuadQuadSquaresEnable(squares, channel);
277  if (squares)
278  {
279  SetQuadQuadSquaresEnable(true, channel);
280  }
281  else
282  {
283  SetQuadQuadFrameEnable(true, channel);
284  }
285  }
286  else
287  {
288  // Non-quad format
289  SetQuadFrameEnable(false, channel);
290  SetQuadQuadFrameEnable(false, channel);
291  if (!IsMultiFormatActive())
292  {
293  CopyVideoFormat(channel, NTV2_CHANNEL1, NTV2_CHANNEL8);
294  }
295  }
296 
297  // Set Progressive Picture State
298  SetProgressivePicture(IsProgressivePicture(value));
299 
300  if (ajaRetail)
301  {
302  // Set the H and V timing (note: this will also set the nominal value for this given format)
303  SetVideoHOffset(hOffset);
304  SetVideoVOffset(vOffset);
305  }
306  else
307  {
308  // All other cards
309  WriteOutputTimingControl(K2_NOMINAL_H | (K2_NOMINAL_V<<16), channel);
310  }
311 
312  if (IsSupported(kDeviceCanDoMultiFormat) && !IsMultiFormatActive())
313  {
314  // Copy channel 1 register write mode to all channels in single format mode
315  NTV2RegisterWriteMode writeMode;
316  GetRegisterWriteMode(writeMode);
317  SetRegisterWriteMode(writeMode);
318  }
319 
320  return true;
321 }
322 
323 bool CNTV2Card::SetVideoFormat (const NTV2ChannelSet & inFrameStores, const NTV2VideoFormat inVideoFormat, bool inIsAJARetail)
324 {
325  size_t errors(0);
326  for (NTV2ChannelSetConstIter it(inFrameStores.begin()); it != inFrameStores.end(); ++it)
327  if (!SetVideoFormat(inVideoFormat, inIsAJARetail, false, *it))
328  errors++;
329  return errors == 0;
330 }
331 
332 // Method: GetVideoFormat
333 // Input: NONE
334 // Output: NTV2VideoFormat
335 bool CNTV2Card::GetVideoFormat (NTV2VideoFormat & outValue, NTV2Channel inChannel)
336 {
337  if (!IsMultiFormatActive () && !IsMultiRasterWidgetChannel(inChannel))
338  inChannel = NTV2_CHANNEL1;
339 
340  NTV2Standard standard;
341  GetStandard (standard, inChannel);
342 
343  NTV2FrameGeometry frameGeometry;
344  GetFrameGeometry (frameGeometry, inChannel);
345 
346  NTV2FrameRate frameRate;
347  GetFrameRate (frameRate, inChannel);
348 
349  ULWord smpte372Enabled;
350  GetSmpte372 (smpte372Enabled, inChannel);
351 
352  ULWord progressivePicture;
353  GetProgressivePicture (progressivePicture);
354 
355  bool isSquares = false;
356  if (NTV2_IS_QUAD_FRAME_GEOMETRY(frameGeometry))
357  {
358  if (!IsSupported(kDeviceCanDo12gRouting))
359  isSquares = true;
360  else
361  Get4kSquaresEnable(isSquares, inChannel);
362  }
363 
364  return ::NTV2DeviceGetVideoFormatFromState_Ex2 (&outValue, frameRate, frameGeometry, standard, smpte372Enabled, progressivePicture, isSquares);
365 }
366 
367 // -------------------------------------------- BEGIN BLOCK
368 // GetNTV2VideoFormat functions
369 // These static functions don't work correctly, and are subject to deprecation. They remain here only by our fiat.
370 
371 NTV2VideoFormat CNTV2Card::GetNTV2VideoFormat(NTV2FrameRate frameRate, UByte inputGeometry, bool progressiveTransport, bool isThreeG, bool progressivePicture)
372 {
373  NTV2Standard standard = GetNTV2StandardFromScanGeometry(inputGeometry, progressiveTransport);
374  return GetNTV2VideoFormat(frameRate, standard, isThreeG, inputGeometry, progressivePicture);
375 }
376 
377 NTV2VideoFormat CNTV2Card::GetNTV2VideoFormat (NTV2FrameRate frameRate, NTV2Standard standard, bool isThreeG, UByte inputGeometry, bool progressivePicture, bool isSquareDivision)
378 {
379  NTV2VideoFormat videoFormat = NTV2_FORMAT_UNKNOWN;
380 
381  switch (standard)
382  {
383  case NTV2_STANDARD_525:
384  switch (frameRate)
385  {
386  case NTV2_FRAMERATE_2997: videoFormat = progressivePicture ? NTV2_FORMAT_525psf_2997 : NTV2_FORMAT_525_5994; break;
387  case NTV2_FRAMERATE_2400: videoFormat = NTV2_FORMAT_525_2400; break;
388  case NTV2_FRAMERATE_2398: videoFormat = NTV2_FORMAT_525_2398; break;
389  default: break;
390  }
391  break;
392 
393  case NTV2_STANDARD_625:
394  if (frameRate == NTV2_FRAMERATE_2500)
395  videoFormat = progressivePicture ? NTV2_FORMAT_625psf_2500 : NTV2_FORMAT_625_5000;
396  break;
397 
398  case NTV2_STANDARD_720:
399  switch (frameRate)
400  {
401  case NTV2_FRAMERATE_6000: videoFormat = NTV2_FORMAT_720p_6000; break;
402  case NTV2_FRAMERATE_5994: videoFormat = NTV2_FORMAT_720p_5994; break;
403  case NTV2_FRAMERATE_5000: videoFormat = NTV2_FORMAT_720p_5000; break;
404  case NTV2_FRAMERATE_2398: videoFormat = NTV2_FORMAT_720p_2398; break;
405  default: break;
406  }
407  break;
408 
409  case NTV2_STANDARD_1080:
410  case NTV2_STANDARD_2Kx1080i:
411  switch (frameRate)
412  {
413  case NTV2_FRAMERATE_3000:
414  if (isThreeG && progressivePicture)
415  videoFormat = NTV2_FORMAT_1080p_6000_B;
416  else
417  videoFormat = progressivePicture ? NTV2_FORMAT_1080psf_3000_2 : NTV2_FORMAT_1080i_6000;
418  break;
419  case NTV2_FRAMERATE_2997:
420  if (isThreeG && progressivePicture)
421  videoFormat = NTV2_FORMAT_1080p_5994_B;
422  else
423  videoFormat = progressivePicture ? NTV2_FORMAT_1080psf_2997_2 : NTV2_FORMAT_1080i_5994;
424  break;
425  case NTV2_FRAMERATE_2500:
426  if (isThreeG && progressivePicture)
427  {
428  if (inputGeometry == 8)
429  videoFormat = NTV2_FORMAT_1080psf_2K_2500;
430  else
431  videoFormat = NTV2_FORMAT_1080p_5000_B;
432  }
433  else if (inputGeometry == 8)
434  videoFormat = NTV2_FORMAT_1080psf_2K_2500;
435  else
436  videoFormat = progressivePicture ? NTV2_FORMAT_1080psf_2500_2 : NTV2_FORMAT_1080i_5000;
437  break;
438  case NTV2_FRAMERATE_2400:
439  if (isThreeG)
440  {
441  videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_4800_B : NTV2_FORMAT_UNKNOWN;
442  }
443  else
444  {
445  videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080psf_2K_2400 : NTV2_FORMAT_1080psf_2400;
446  }
447  break;
448  case NTV2_FRAMERATE_2398:
449  if (isThreeG)
450  {
451  videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_4795_B : NTV2_FORMAT_UNKNOWN;
452  }
453  else
454  {
455  videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080psf_2K_2398 : NTV2_FORMAT_1080psf_2398;
456  }
457  break;
458  default: break; // Unsupported
459  }
460  break;
461 
462  case NTV2_STANDARD_1080p:
463  case NTV2_STANDARD_2Kx1080p:
464  switch (frameRate)
465  {
466  case NTV2_FRAMERATE_12000: videoFormat = NTV2_FORMAT_4x2048x1080p_12000; break; // There's no single quadrant raster defined for 120 Hz raw
467  case NTV2_FRAMERATE_11988: videoFormat = NTV2_FORMAT_4x2048x1080p_11988; break; // There's no single quadrant raster defined for 119.88 Hz raw
468  case NTV2_FRAMERATE_6000: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_6000_A : NTV2_FORMAT_1080p_6000_A; break;
469  case NTV2_FRAMERATE_5994: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_5994_A : NTV2_FORMAT_1080p_5994_A; break;
470  case NTV2_FRAMERATE_4800: videoFormat = NTV2_FORMAT_1080p_2K_4800_A; break; // There's no 1920 raster defined at 48 Hz
471  case NTV2_FRAMERATE_4795: videoFormat = NTV2_FORMAT_1080p_2K_4795_A; break; // There's no 1920 raster defined at 47.95 Hz
472  case NTV2_FRAMERATE_5000: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_5000_A : NTV2_FORMAT_1080p_5000_A; break;
473  case NTV2_FRAMERATE_3000: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_3000 : NTV2_FORMAT_1080p_3000; break;
474  case NTV2_FRAMERATE_2997: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_2997 : NTV2_FORMAT_1080p_2997; break;
475  case NTV2_FRAMERATE_2500: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_2500 : NTV2_FORMAT_1080p_2500; break;
476  case NTV2_FRAMERATE_2400: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_2400 : NTV2_FORMAT_1080p_2400; break;
477  case NTV2_FRAMERATE_2398: videoFormat = inputGeometry == 8 ? NTV2_FORMAT_1080p_2K_2398 : NTV2_FORMAT_1080p_2398; break;
478  default: break; // Unsupported
479  }
480  break;
481 
482  case NTV2_STANDARD_2K: // 2kx1556
483  switch (frameRate)
484  {
485  case NTV2_FRAMERATE_1500: videoFormat = NTV2_FORMAT_2K_1500; break;
486  case NTV2_FRAMERATE_1498: videoFormat = NTV2_FORMAT_2K_1498; break;
487  case NTV2_FRAMERATE_2400: videoFormat = NTV2_FORMAT_2K_2400; break;
488  case NTV2_FRAMERATE_2398: videoFormat = NTV2_FORMAT_2K_2398; break;
489  case NTV2_FRAMERATE_2500: videoFormat = NTV2_FORMAT_2K_2500; break;
490  default: break; // Unsupported
491  }
492  break;
493 
494  case NTV2_STANDARD_3840HFR: videoFormat = NTV2_FORMAT_UNKNOWN; break;
495 
496  case NTV2_STANDARD_3840x2160p:
497  switch (frameRate)
498  {
499  case NTV2_FRAMERATE_2398: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_2398 : NTV2_FORMAT_3840x2160p_2398; break;
500  case NTV2_FRAMERATE_2400: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_2400 : NTV2_FORMAT_3840x2160p_2400; break;
501  case NTV2_FRAMERATE_2500: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_2500 : NTV2_FORMAT_3840x2160p_2500; break;
502  case NTV2_FRAMERATE_2997: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_2997 : NTV2_FORMAT_3840x2160p_2997; break;
503  case NTV2_FRAMERATE_3000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_3000 : NTV2_FORMAT_3840x2160p_3000; break;
504  case NTV2_FRAMERATE_5000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_5000 : NTV2_FORMAT_3840x2160p_5000; break;
505  case NTV2_FRAMERATE_5994: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_5994 : NTV2_FORMAT_3840x2160p_5994; break;
506  case NTV2_FRAMERATE_6000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080p_6000 : NTV2_FORMAT_3840x2160p_6000; break;
507  default: videoFormat = NTV2_FORMAT_UNKNOWN; break;
508  }
509  break;
510 
511  case NTV2_STANDARD_3840i:
512  switch (frameRate)
513  {
514  case NTV2_FRAMERATE_2398: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080psf_2398 : NTV2_FORMAT_3840x2160psf_2398; break;
515  case NTV2_FRAMERATE_2400: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080psf_2400 : NTV2_FORMAT_3840x2160psf_2400; break;
516  case NTV2_FRAMERATE_2500: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080psf_2500 : NTV2_FORMAT_3840x2160psf_2500; break;
517  case NTV2_FRAMERATE_2997: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080psf_2997 : NTV2_FORMAT_3840x2160psf_2997; break;
518  case NTV2_FRAMERATE_3000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x1920x1080psf_3000 : NTV2_FORMAT_3840x2160psf_3000; break;
519  default: videoFormat = NTV2_FORMAT_UNKNOWN; break;
520  }
521  break;
522 
523  case NTV2_STANDARD_4096HFR: videoFormat = NTV2_FORMAT_UNKNOWN; break;
524 
525  case NTV2_STANDARD_4096x2160p:
526  switch (frameRate)
527  {
528  case NTV2_FRAMERATE_2398: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_2398 : NTV2_FORMAT_4096x2160p_2398; break;
529  case NTV2_FRAMERATE_2400: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_2400 : NTV2_FORMAT_4096x2160p_2400; break;
530  case NTV2_FRAMERATE_2500: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_2500 : NTV2_FORMAT_4096x2160p_2500; break;
531  case NTV2_FRAMERATE_2997: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_2997 : NTV2_FORMAT_4096x2160p_2997; break;
532  case NTV2_FRAMERATE_3000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_3000 : NTV2_FORMAT_4096x2160p_3000; break;
533  case NTV2_FRAMERATE_4795: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_4795 : NTV2_FORMAT_4096x2160p_4795; break;
534  case NTV2_FRAMERATE_4800: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_4800 : NTV2_FORMAT_4096x2160p_4800; break;
535  case NTV2_FRAMERATE_5000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_5000 : NTV2_FORMAT_4096x2160p_5000; break;
536  case NTV2_FRAMERATE_5994: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_5994 : NTV2_FORMAT_4096x2160p_5994; break;
537  case NTV2_FRAMERATE_6000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080p_6000 : NTV2_FORMAT_4096x2160p_6000; break;
538  default: videoFormat = NTV2_FORMAT_UNKNOWN; break;
539  }
540  break;
541 
542  case NTV2_STANDARD_4096i:
543  switch (frameRate)
544  {
545  case NTV2_FRAMERATE_2398: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080psf_2398 : NTV2_FORMAT_4096x2160psf_2398; break;
546  case NTV2_FRAMERATE_2400: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080psf_2400 : NTV2_FORMAT_4096x2160psf_2400; break;
547  case NTV2_FRAMERATE_2500: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080psf_2500 : NTV2_FORMAT_4096x2160psf_2500; break;
548  case NTV2_FRAMERATE_2997: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080psf_2997 : NTV2_FORMAT_4096x2160psf_2997; break;
549  case NTV2_FRAMERATE_3000: videoFormat = isSquareDivision ? NTV2_FORMAT_4x2048x1080psf_3000 : NTV2_FORMAT_4096x2160psf_3000; break;
550  default: videoFormat = NTV2_FORMAT_UNKNOWN; break;
551  }
552  break;
553 
554  case NTV2_STANDARD_7680:
555  switch(frameRate)
556  {
557  case NTV2_FRAMERATE_2398: videoFormat = NTV2_FORMAT_4x3840x2160p_2398; break;
558  case NTV2_FRAMERATE_2400: videoFormat = NTV2_FORMAT_4x3840x2160p_2400; break;
559  case NTV2_FRAMERATE_2500: videoFormat = NTV2_FORMAT_4x3840x2160p_2500; break;
560  case NTV2_FRAMERATE_2997: videoFormat = NTV2_FORMAT_4x3840x2160p_2997; break;
561  case NTV2_FRAMERATE_3000: videoFormat = NTV2_FORMAT_4x3840x2160p_3000; break;
562  case NTV2_FRAMERATE_5000: videoFormat = NTV2_FORMAT_4x3840x2160p_5000; break;
563  case NTV2_FRAMERATE_5994: videoFormat = NTV2_FORMAT_4x3840x2160p_5994; break;
564  case NTV2_FRAMERATE_6000: videoFormat = NTV2_FORMAT_4x3840x2160p_6000; break;
565  default: videoFormat = NTV2_FORMAT_UNKNOWN;
566  }
567  break;
568 
569  case NTV2_STANDARD_8192:
570  switch(frameRate)
571  {
572  case NTV2_FRAMERATE_2398: videoFormat = NTV2_FORMAT_4x4096x2160p_2398; break;
573  case NTV2_FRAMERATE_2400: videoFormat = NTV2_FORMAT_4x4096x2160p_2400; break;
574  case NTV2_FRAMERATE_2500: videoFormat = NTV2_FORMAT_4x4096x2160p_2500; break;
575  case NTV2_FRAMERATE_2997: videoFormat = NTV2_FORMAT_4x4096x2160p_2997; break;
576  case NTV2_FRAMERATE_3000: videoFormat = NTV2_FORMAT_4x4096x2160p_3000; break;
577  case NTV2_FRAMERATE_4795: videoFormat = NTV2_FORMAT_4x4096x2160p_4795; break;
578  case NTV2_FRAMERATE_4800: videoFormat = NTV2_FORMAT_4x4096x2160p_4800; break;
579  case NTV2_FRAMERATE_5000: videoFormat = NTV2_FORMAT_4x4096x2160p_5000; break;
580  case NTV2_FRAMERATE_5994: videoFormat = NTV2_FORMAT_4x4096x2160p_5994; break;
581  case NTV2_FRAMERATE_6000: videoFormat = NTV2_FORMAT_4x4096x2160p_6000; break;
582  default: videoFormat = NTV2_FORMAT_UNKNOWN;
583  }
584  break;
585 
586  case NTV2_STANDARD_UNDEFINED:
587  videoFormat = NTV2_FORMAT_UNKNOWN;
588  break;
589  }
590 
591  return videoFormat;
592 
593 } // GetNTV2VideoFormat
594 
595 // -------------------------------------------- END BLOCK
596 
597 bool CNTV2Card::GetNominalMinMaxHV (int & outNominalH, int & outMinH, int & outMaxH, int & outNominalV, int & outMinV, int & outMaxV)
598 {
599  NTV2VideoFormat videoFormat;
600  // Get current video format to find nominal value
601  if (GetVideoFormat(videoFormat))
602  {
603  // Kona2 has static nominal H value for all formats
604  outNominalH = K2_NOMINAL_H;
605  outMinH = K2_MIN_H;
606  outMaxH = K2_MAX_H;
607 
608  outNominalV = K2_NOMINAL_V;
609  outMinV = K2_MIN_V;
610  outMaxV = K2_MAX_V;
611  return true;
612  }
613  return false;
614 }
615 
616 bool CNTV2Card::SetVideoHOffset (int hOffset, const UWord inOutputSpigot)
617 {
618  int nominalH(0), minH(0), maxH(0), nominalV(0), minV(0), maxV(0), count(0);
619  ULWord timingValue(0), lineCount(0), lineCount2(0);
620  NTV2DeviceID boardID(GetDeviceID());
621 
622  // Get the nominal values for H and V
623  if (!GetNominalMinMaxHV(nominalH, minH, maxH, nominalV, minV, maxV))
624  return false;
625 
626  // Apply offset to nominal value (K2 you increment the timing by adding the timing value)
627  if (::NTV2DeviceNeedsRoutingSetup(boardID))
628  nominalH = nominalH + hOffset;
629  else
630  nominalH = nominalH - hOffset;
631 
632  // Clamp this value so that it doesn't exceed max, min
633  if (nominalH > maxH)
634  nominalH = maxH;
635  else if (nominalH < minH)
636  nominalH = minH;
637 
638  if (!ReadOutputTimingControl(timingValue, inOutputSpigot))
639  return false;
640 
641  // Handle special cases where we increment or decrement the timing by one
642  // Some hardware LS/LH cannot handle this and inorder to do 1 pixel timing moves
643  // we need to move by 3 then subtract 2, or subtract 3 then add 2 depending on
644  // direction. Also we need to wait at least one horizontal line between the values
645  // we set.
646 
647  if (LWord((timingValue & 0x0000FFFF)) == nominalH)
648  return true; // Nothing to change
649  if (((LWord((timingValue & 0x0000FFFF)) + 1) == nominalH) )
650  {
651  // Add 3 to the timing value. Note that nominalH is already advanced by one so
652  // we just need to add 2.
653  timingValue &= 0xFFFF0000;
654  timingValue |= ULWord(nominalH + 2);
655  WriteOutputTimingControl(timingValue, inOutputSpigot);
656 
657  // Wait a scanline
658  count = 0;
659  ReadLineCount (lineCount);
660  do
661  {
662  ReadLineCount (lineCount2);
663  if (count > 1000000) return false;
664  count++;
665  } while (lineCount == lineCount2);
666 
667  // Now move timing back by 2.
668  timingValue -= 2;
669  }
670  else if ( ((LWord((timingValue & 0x0000FFFF)) -1) == nominalH ) )
671  {
672  // Subtract 3 from the timing value. Note that nominalH is already decremented by one so
673  // we just need to subtract 2.
674  timingValue &= 0xFFFF0000;
675  timingValue |= ULWord(nominalH - 2);
676  WriteOutputTimingControl(timingValue, inOutputSpigot);
677 
678  // Wait a scanline
679  count = 0;
680  ReadLineCount (lineCount);
681  do
682  {
683  ReadLineCount (lineCount2);
684  if (count > 1000000) return false;
685  count++;
686  } while (lineCount == lineCount2);
687 
688  // Now move timing forward by 2.
689  timingValue += 2;
690  }
691  else
692  {
693  // Setting arbitrary value so we don't need to do the +3-2 or -3+2 trick and
694  // we can just set the new value
695  timingValue &= 0xFFFF0000;
696  timingValue |= ULWord(nominalH);
697  }
698  return WriteOutputTimingControl(timingValue, inOutputSpigot);
699 } // SetVideoHOffset
700 
701 
702 bool CNTV2Card::GetVideoHOffset (int & outHOffset, const UWord inOutputSpigot)
703 {
704  int nominalH(0), minH(0), maxH(0), nominalV(0), minV(0), maxV(0);
705 
706  // Get the nominal values for H and V...
707  if (!GetNominalMinMaxHV(nominalH, minH, maxH, nominalV, minV, maxV))
708  return false;
709 
710  ULWord timingValue(0);
711  if (!ReadOutputTimingControl(timingValue, inOutputSpigot))
712  return false;
713  timingValue &= 0xFFFF; // lower 16 bits has H timing value -- 0x1000 is nominal
714 
715  // Get offset from nominal value (K2 you increment the timing by adding the timing value)
716  if (::NTV2DeviceNeedsRoutingSetup(GetDeviceID()))
717  outHOffset = int(timingValue) - nominalH;
718  else
719  outHOffset = nominalH - int(timingValue);
720  return true;
721 }
722 
723 bool CNTV2Card::SetVideoVOffset (int vOffset, const UWord inOutputSpigot)
724 {
725  int nominalH(0), minH(0), maxH(0), nominalV(0), minV(0), maxV(0);
726 
727  // Get the nominal values for H and V
728  if (!GetNominalMinMaxHV(nominalH, minH, maxH, nominalV, minV, maxV))
729  return false;
730 
731  // Apply offset to nominal value (K2 you increment the timing by adding the timing value)
732  if (::NTV2DeviceNeedsRoutingSetup(GetDeviceID()))
733  nominalV = nominalV + vOffset;
734  else
735  nominalV = nominalV - vOffset;
736 
737  // Clamp this value so that it doesn't exceed max, min
738  if (nominalV > maxV)
739  nominalV = maxV;
740  else if (nominalV < minV)
741  nominalV = minV;
742 
743  ULWord timingValue(0);
744  if (!ReadOutputTimingControl(timingValue, inOutputSpigot))
745  return false;
746  timingValue &= 0x0000FFFF; // Clear V value, keep H value
747  return WriteOutputTimingControl(timingValue | ULWord(nominalV << 16), inOutputSpigot); // Change only the V value
748 }
749 
750 bool CNTV2Card::GetVideoVOffset (int & outVOffset, const UWord inOutputSpigot)
751 {
752  int nominalH(0), minH(0), maxH(0), nominalV(0), minV(0), maxV(0);
753 
754  // Get the nominal values for H and V
755  if (!GetNominalMinMaxHV(nominalH, minH, maxH, nominalV, minV, maxV))
756  return false;
757 
758  ULWord timingValue(0);
759  if (!ReadOutputTimingControl(timingValue, inOutputSpigot))
760  return false;
761  timingValue = (timingValue >> 16);
762 
763  // Get offset from nominal value (K2 you increment the timing by adding the timing value)
764  if (::NTV2DeviceNeedsRoutingSetup(GetDeviceID()))
765  outVOffset = int(timingValue) - nominalV;
766  else
767  outVOffset = nominalV - int(timingValue);
768  return true;
769 }
770 
771 #if !defined(NTV2_DEPRECATE_16_2)
772  bool CNTV2Card::GetNumberActiveLines (ULWord & outNumActiveLines)
773  {
774  outNumActiveLines = 0;
775  NTV2Standard st; NTV2VANCMode vm;
776  if (!GetStandard(st) || !GetVANCMode(vm))
777  return false;
778  const NTV2FormatDescriptor fd(st, NTV2_FBF_10BIT_YCBCR, vm);
779  return fd.GetRasterHeight();
780  }
781 
782  bool CNTV2Card::GetActiveFrameDimensions (NTV2FrameDimensions & outFrameDimensions, const NTV2Channel inChannel)
783  {
784  NTV2Standard st(NTV2_STANDARD_INVALID); NTV2VANCMode vm(NTV2_VANCMODE_INVALID);
785  outFrameDimensions.Reset();
786  if (IsXilinxProgrammed() && GetStandard(st, inChannel) && GetVANCMode(vm, inChannel))
787  { const NTV2FormatDescriptor fd (st, NTV2_FBF_10BIT_YCBCR, vm);
788  outFrameDimensions.Set (fd.GetRasterWidth(), fd.GetRasterHeight());
789  }
790  return outFrameDimensions.IsValid();
791  }
792 
793 
794  NTV2FrameDimensions CNTV2Card::GetActiveFrameDimensions (const NTV2Channel inChannel)
795  {
796  NTV2Standard st; NTV2VANCMode vm; NTV2FrameDimensions result;
797  if (!IsXilinxProgrammed() || !GetStandard(st, inChannel) || !GetVANCMode(vm, inChannel))
798  return result;
799  const NTV2FormatDescriptor fd (st, NTV2_FBF_10BIT_YCBCR, vm);
800  return result.Set (fd.GetRasterWidth(), fd.GetRasterHeight());
801  }
802 #endif // defined(NTV2_DEPRECATE_16_2)
803 
804 // Method: SetStandard
805 // Input: NTV2Standard
806 // Output: NONE
807 bool CNTV2Card::SetStandard (NTV2Standard value, NTV2Channel inChannel)
808 {
809  if (IsMultiRasterWidgetChannel(inChannel))
810  return WriteRegister (kRegMROutControl, value, kRegMaskStandard, kRegShiftStandard);
811  if (!IsMultiFormatActive())
812  inChannel = NTV2_CHANNEL1;
813 
814  NTV2Standard newStandard (value);
815  if (NTV2_IS_QUAD_QUAD_STANDARD(newStandard))
816  newStandard = GetQuarterSizedStandard(newStandard);
817  if (NTV2_IS_QUAD_STANDARD(newStandard))
818  newStandard = GetQuarterSizedStandard(newStandard);
819  if (NTV2_IS_2K1080_STANDARD(newStandard))
820  newStandard = NTV2_IS_PROGRESSIVE_STANDARD(newStandard) ? NTV2_STANDARD_1080p : NTV2_STANDARD_1080;
821 
822  return WriteRegister (gChannelToGlobalControlRegNum[inChannel], newStandard, kRegMaskStandard, kRegShiftStandard);
823 }
824 
825 // Method: GetStandard
826 // Input: NONE
827 // Output: NTV2Standard
828 bool CNTV2Card::GetStandard (NTV2Standard & outValue, NTV2Channel inChannel)
829 {
830  if (IsMultiRasterWidgetChannel(inChannel))
831  return CNTV2DriverInterface::ReadRegister(kRegMROutControl, outValue, kRegMaskMRStandard, kRegShiftMRStandard);
832  if (!IsMultiFormatActive())
833  inChannel = NTV2_CHANNEL1;
834  bool status = CNTV2DriverInterface::ReadRegister (gChannelToGlobalControlRegNum[inChannel], outValue, kRegMaskStandard, kRegShiftStandard);
835  if (status && IsSupported(kDeviceCanDo4KVideo))// || IsSupported(kDeviceCanDo425Mux)))
836  {
837  bool quadFrameEnabled(false);
838  status = GetQuadFrameEnable(quadFrameEnabled, inChannel);
839  if (status && quadFrameEnabled)
840  outValue = Get4xSizedStandard(outValue);
841  if( status && IsSupported(kDeviceCanDo8KVideo))
842  {
843  bool quadQuadFrameEnabled(false);
844  status = GetQuadQuadFrameEnable(quadQuadFrameEnabled);
845  if(status && quadQuadFrameEnabled)
846  outValue = Get4xSizedStandard(outValue);
847  }
848  }
849  return status;
850 }
851 
852 // Method: IsProgressiveStandard
853 // Input: NONE
854 // Output: bool
855 bool CNTV2Card::IsProgressiveStandard (bool & outIsProgressive, NTV2Channel inChannel)
856 {
857  ULWord smpte372Enabled (0);
858  NTV2Standard standard (NTV2_STANDARD_INVALID);
859  outIsProgressive = false;
860 
861  if (!IsMultiFormatActive())
862  inChannel = NTV2_CHANNEL1;
863 
864  if (GetStandard (standard, inChannel) && GetSmpte372 (smpte372Enabled, inChannel))
865  {
866  if (standard == NTV2_STANDARD_720 || standard == NTV2_STANDARD_1080p || smpte372Enabled)
867  outIsProgressive = true;
868  return true;
869  }
870  return false;
871 }
872 
873 // Method: IsSDStandard
874 // Input: NONE
875 // Output: bool
876 bool CNTV2Card::IsSDStandard (bool & outIsStandardDef, NTV2Channel inChannel)
877 {
878  NTV2Standard standard (NTV2_STANDARD_INVALID);
879  outIsStandardDef = false;
880 
881  if (!IsMultiFormatActive())
882  inChannel = NTV2_CHANNEL1;
883 
884  if (GetStandard (standard, inChannel))
885  {
886  if (standard == NTV2_STANDARD_525 || standard == NTV2_STANDARD_625)
887  outIsStandardDef = true; // SD standard
888  return true;
889  }
890  return false;
891 }
892 
893 
894 // Method: SetFrameGeometry
895 // Input: NTV2FrameGeometry
896 // Output: NONE
897 bool CNTV2Card::SetFrameGeometry (NTV2FrameGeometry value, bool ajaRetail, NTV2Channel channel)
898 {
899 #ifdef MSWindows
900  NTV2EveryFrameTaskMode mode;
901  GetEveryFrameServices(mode);
902  if(mode == NTV2_STANDARD_TASKS)
903  ajaRetail = true;
904 #else
905  (void) ajaRetail;
906 #endif
907  if (IsMultiRasterWidgetChannel(channel))
908  return false;
909  if (!IsMultiFormatActive())
910  channel = NTV2_CHANNEL1;
911  else if (IS_CHANNEL_INVALID(channel))
912  return false;
913 
914  const ULWord regNum (gChannelToGlobalControlRegNum [channel]);
915  const NTV2FrameGeometry newGeometry (value);
916  NTV2FrameBufferFormat format (NTV2_FBF_NUMFRAMEBUFFERFORMATS);
917 
918  // This is the geometry of a single FB widget. Note this is the same as newGeometry unless it is a 4K format
919  NTV2FrameGeometry newFrameStoreGeometry = newGeometry;
920  NTV2FrameGeometry oldGeometry;
921  bool status = GetFrameGeometry(oldGeometry, channel);
922  if ( !status )
923  return status;
924 
925  status = GetLargestFrameBufferFormatInUse(format);
926  if ( !status )
927  return status;
928 
929  // If quad frame geometry, each of 4 frame buffers geometry is one quarter of full size
930  if (IsSupported(kDeviceCanDo4KVideo))
931  {
932  newFrameStoreGeometry = newGeometry;
933  if (NTV2_IS_QUAD_QUAD_FRAME_GEOMETRY(newFrameStoreGeometry))
934  {
935  newFrameStoreGeometry = GetQuarterSizedGeometry(newFrameStoreGeometry);
936  }
937  if (NTV2_IS_QUAD_FRAME_GEOMETRY(newFrameStoreGeometry))
938  {
939  newFrameStoreGeometry = GetQuarterSizedGeometry(newFrameStoreGeometry);
940  }
941  }
942 
943  ULWord oldFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID, oldGeometry, format);
944  ULWord newFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID, newGeometry, format);
945  bool changeBufferSize = IsSupported(kDeviceCanChangeFrameBufferSize) && (oldFrameBufferSize != newFrameBufferSize);
946 
947  status = WriteRegister (regNum, newFrameStoreGeometry, kRegMaskGeometry, kRegShiftGeometry);
948 
949  // If software set the frame buffer size, read the values from hardware
950  if ( GetFBSizeAndCountFromHW(_ulFrameBufferSize, _ulNumFrameBuffers) )
951  {
952  changeBufferSize = false;
953  }
954 
955  // Unfortunately, on boards that support 2k, the
956  // numframebuffers and framebuffersize might need to
957  // change.
958  if ( changeBufferSize )
959  {
960  _ulFrameBufferSize = newFrameBufferSize;
961  _ulNumFrameBuffers = ::NTV2DeviceGetNumberFrameBuffers(_boardID, newGeometry, format);
962  }
963 
964  return status;
965 }
966 
967 // Method: GetFrameGeometry
968 // Input: NONE
969 // Output: NTV2FrameGeometry
970 bool CNTV2Card::GetFrameGeometry (NTV2FrameGeometry & outValue, NTV2Channel inChannel)
971 {
972  outValue = NTV2_FG_INVALID;
973  if (IsMultiRasterWidgetChannel(inChannel))
974  { // TBD: Determine if multiraster is UHD or 4K:
975  outValue = 1 ? NTV2_FG_4x1920x1080 : NTV2_FG_4x2048x1080;
976  return true;
977  }
978  if (!IsMultiFormatActive())
979  inChannel = NTV2_CHANNEL1;
980  else if (IS_CHANNEL_INVALID(inChannel))
981  return false;
982 
983  bool status = CNTV2DriverInterface::ReadRegister (gChannelToGlobalControlRegNum[inChannel], outValue, kRegMaskGeometry, kRegShiftGeometry);
984  // special case for quad-frame (4 frame buffer) geometry
985  if (status && (IsSupported(kDeviceCanDo4KVideo) || IsSupported(kDeviceCanDo425Mux)))
986  {
987  bool quadFrameEnabled(false);
988  status = GetQuadFrameEnable(quadFrameEnabled, inChannel);
989  if (status && quadFrameEnabled)
990  outValue = Get4xSizedGeometry(outValue);
991  if (status && IsSupported(kDeviceCanDo8KVideo))
992  {
993  bool quadQuadFrameEnabled(false);
994  status = GetQuadQuadFrameEnable(quadQuadFrameEnabled);
995  if (status && quadQuadFrameEnabled)
996  outValue = Get4xSizedGeometry(outValue);
997  }
998  }
999  return status;
1000 }
1001 
1002 // Method: SetFramerate
1003 // Input: NTV2FrameRate
1004 // Output: NONE
1005 bool CNTV2Card::SetFrameRate (NTV2FrameRate value, NTV2Channel inChannel)
1006 {
1007  const ULWord loValue (value & 0x7);
1008  const ULWord hiValue ((value & 0x8) >> 3);
1009 
1010  if (IsMultiRasterWidgetChannel(inChannel))
1011  return false;
1012  if (!IsMultiFormatActive ())
1013  inChannel = NTV2_CHANNEL1;
1014 
1015  return WriteRegister (gChannelToGlobalControlRegNum[inChannel], loValue, kRegMaskFrameRate, kRegShiftFrameRate) &&
1016  WriteRegister (gChannelToGlobalControlRegNum[inChannel], hiValue, kRegMaskFrameRateHiBit, kRegShiftFrameRateHiBit);
1017 }
1018 
1019 // Method: GetFrameRate
1020 // Input: NONE
1021 // Output: NTV2FrameRate
1022 bool CNTV2Card::GetFrameRate (NTV2FrameRate & outValue, NTV2Channel inChannel)
1023 {
1024  ULWord returnVal1 (0), returnVal2 (0);
1025  outValue = NTV2_FRAMERATE_UNKNOWN;
1026  if (IsMultiRasterWidgetChannel(inChannel))
1027  return CNTV2DriverInterface::ReadRegister(kRegMROutControl, outValue, /*mask*/0x00000070, /*shift*/4);
1028  if (!IsMultiFormatActive())
1029  inChannel = NTV2_CHANNEL1;
1030  else if (IS_CHANNEL_INVALID(inChannel))
1031  return false;
1032 
1033  if (ReadRegister (gChannelToGlobalControlRegNum[inChannel], returnVal1, kRegMaskFrameRate, kRegShiftFrameRate) &&
1034  ReadRegister (gChannelToGlobalControlRegNum[inChannel], returnVal2, kRegMaskFrameRateHiBit, kRegShiftFrameRateHiBit))
1035  {
1036  outValue = NTV2FrameRate((returnVal1 & 0x7) | ((returnVal2 & 0x1) << 3));
1037  return true;
1038  }
1039  return false;
1040 }
1041 
1042 // Method: SetSmpte372
1043 bool CNTV2Card::SetSmpte372 (ULWord inValue, NTV2Channel inChannel)
1044 {
1045  // Set true (1) to put card in SMPTE 372 dual-link mode (used for 1080p60, 1080p5994, 1080p50)
1046  // Set false (0) to disable this mode
1047  if (IsMultiRasterWidgetChannel(inChannel))
1048  return inValue == 0;
1049  if (!IsMultiFormatActive())
1050  inChannel = NTV2_CHANNEL1;
1051 
1052  return WriteRegister (gChannelToSmpte372RegisterNum [inChannel], inValue, gChannelToSmpte372Masks [inChannel], gChannelToSmpte372Shifts [inChannel]);
1053 }
1054 
1055 // Method: GetSmpte372
1056 bool CNTV2Card::GetSmpte372 (ULWord & outValue, NTV2Channel inChannel)
1057 {
1058  // Return true (1) if card in SMPTE 372 dual-link mode (used for 1080p60, 1080p5994, 1080p50)
1059  // Return false (0) if this mode is disabled
1060  if (IsMultiRasterWidgetChannel(inChannel))
1061  {outValue = 0; return true;}
1062  if (!IsMultiFormatActive())
1063  inChannel = NTV2_CHANNEL1;
1064 
1065  return ReadRegister (gChannelToSmpte372RegisterNum[inChannel], outValue, gChannelToSmpte372Masks[inChannel], gChannelToSmpte372Shifts[inChannel]);
1066 }
1067 
1068 // Method: SetProgressivePicture
1069 // Input: bool -- Set true (1) to put card video format into progressive mode (used for 1080psf25 vs 1080i50, etc);
1070 // Set false (0) to disable this mode
1071 // Output: NONE
1072 bool CNTV2Card::SetProgressivePicture (ULWord value)
1073 {
1074  return WriteRegister (kVRegProgressivePicture, value);
1075 }
1076 
1077 // Method: GetProgressivePicture
1078 // Input: NONE
1079 // Output: bool -- Return true (1) if card video format is progressive (used for 1080psf25 vs 1080i50, etc);
1080 // Return false (0) if this mode is disabled
1081 bool CNTV2Card::GetProgressivePicture (ULWord & outValue)
1082 {
1083  ULWord returnVal (0);
1084  bool result1 (ReadRegister (kVRegProgressivePicture, returnVal));
1085  outValue = result1 ? returnVal : 0;
1086  return result1;
1087 }
1088 
1089 // Method: SetQuadFrameEnable
1090 // Input: bool
1091 // Output: NONE
1092 bool CNTV2Card::SetQuadFrameEnable (const bool inEnable, const NTV2Channel inChannel)
1093 {
1094  if (!IsSupported(kDeviceCanDo4KVideo))
1095  return false;
1096  if (IsMultiRasterWidgetChannel(inChannel))
1097  return inEnable == true;
1098  bool ok(NTV2_IS_VALID_CHANNEL(inChannel));
1099 
1100  // Set true (1) to enable a Quad Frame Geometry
1101  // Set false (0) to disable this mode
1102  if (inEnable)
1103  {
1104  if (IsSupported(kDeviceCanDo12gRouting))
1105  {
1106  if (ok) ok = SetTsiFrameEnable(true, inChannel);
1107  }
1108  else if (IsSupported(kDeviceCanDo425Mux))
1109  {
1110  if(ok) ok = SetTsiFrameEnable(true, inChannel);
1111  }
1112  else
1113  {
1114  if(ok) ok = Set4kSquaresEnable(true, inChannel);
1115  }
1116  }
1117  else
1118  {
1119  SetTsiFrameEnable(false, inChannel);
1120  Set4kSquaresEnable(false, inChannel);
1121  }
1122  return ok;
1123 }
1124 
1125 bool CNTV2Card::SetQuadQuadFrameEnable (const bool inEnable, const NTV2Channel inChannel)
1126 {
1127  if (!IsSupported(kDeviceCanDo8KVideo))
1128  return false;
1129  if (IsMultiRasterWidgetChannel(inChannel))
1130  return false;
1131  bool ok(NTV2_IS_VALID_CHANNEL(inChannel));
1132  if (inEnable)
1133  {
1134  if (!IsMultiFormatActive())
1135  {
1136  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL1);
1137  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL2);
1138  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL3);
1139  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL4);
1140  }
1141  else if (inChannel < NTV2_CHANNEL3)
1142  {
1143  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL1);
1144  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL2);
1145  }
1146  else if (inChannel < NTV2_CHANNEL5)
1147  {
1148  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL3);
1149  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL4);
1150  }
1151  }
1152  else
1153  {
1154  if(ok) ok = SetQuadQuadSquaresEnable(false, inChannel);
1155  }
1156 
1157  if (!IsMultiFormatActive())
1158  {
1159  WriteRegister(kRegGlobalControl3, ULWord(inEnable ? 1 : 0), kRegMaskQuadQuadMode, kRegShiftQuadQuadMode);
1160  WriteRegister(kRegGlobalControl3, ULWord(inEnable ? 1 : 0), kRegMaskQuadQuadMode2, kRegShiftQuadQuadMode2);
1161  }
1162  else
1163  {
1164  if (ok) ok = WriteRegister(kRegGlobalControl3, ULWord(inEnable ? 1 : 0), (inChannel < NTV2_CHANNEL3) ? kRegMaskQuadQuadMode : kRegMaskQuadQuadMode2, (inChannel < NTV2_CHANNEL3) ? kRegShiftQuadQuadMode : kRegShiftQuadQuadMode2);
1165  }
1166  if (inEnable)
1167  {
1168  if (inChannel < NTV2_CHANNEL3)
1169  {
1170  if (ok) ok = CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL2);
1171  }
1172  else
1173  {
1174  if (ok) ok = CopyVideoFormat(inChannel, NTV2_CHANNEL3, NTV2_CHANNEL4);
1175  }
1176  }
1177  return ok;
1178 }
1179 
1180 bool CNTV2Card::SetQuadQuadSquaresEnable (const bool inValue, const NTV2Channel inChannel)
1181 {
1182  (void)inChannel;
1183  bool ok(IsSupported(kDeviceCanDo8KVideo));
1184  if (inValue)
1185  {
1186  if (ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL1);
1187  if (ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL2);
1188  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL3);
1189  if(ok) ok = SetQuadFrameEnable(true, NTV2_CHANNEL4);
1190  if(ok) ok = SetQuadQuadFrameEnable(true, NTV2_CHANNEL1);
1191  if(ok) ok = SetQuadQuadFrameEnable(true, NTV2_CHANNEL3);
1192  }
1193  if(ok) ok = WriteRegister(kRegGlobalControl3, ULWord(inValue ? 1 : 0), kRegMaskQuadQuadSquaresMode, kRegShiftQuadQuadSquaresMode);
1194  return ok;
1195 }
1196 
1197 bool CNTV2Card::GetQuadQuadSquaresEnable (bool & outValue, const NTV2Channel inChannel)
1198 {
1199  (void)inChannel;
1200  if (!IsSupported(kDeviceCanDo8KVideo))
1201  return false;
1202 
1203  return CNTV2DriverInterface::ReadRegister(kRegGlobalControl3, outValue, kRegMaskQuadQuadSquaresMode, kRegShiftQuadQuadSquaresMode);
1204 }
1205 
1206 // Method: GetQuadFrameEnable
1207 // Input: NONE
1208 // Output: bool
1209 bool CNTV2Card::GetQuadFrameEnable (bool & outValue, const NTV2Channel inChannel)
1210 {
1211  // Return true (1) Quad Frame Geometry is enabled
1212  // Return false (0) if this mode is disabled
1213  bool quadEnabled (0);
1214  bool status2 (true);
1215  bool s425Enabled (false);
1216  bool status1 = Get4kSquaresEnable (quadEnabled, inChannel);
1217  if (IsSupported(kDeviceCanDo425Mux) || IsSupported(kDeviceCanDo12gRouting))
1218  status2 = GetTsiFrameEnable (s425Enabled, inChannel);
1219 
1220  outValue = (status1 & status2) ? ((quadEnabled | s425Enabled) ? true : false) : false;
1221  return status1;
1222 }
1223 
1224 bool CNTV2Card::GetQuadQuadFrameEnable (bool & outValue, const NTV2Channel inChannel)
1225 {
1226  (void) inChannel; // Channel ignored for now
1227  outValue = false;
1228  if (IsSupported(kDeviceCanDo8KVideo))
1229  {
1230  if (inChannel < NTV2_CHANNEL3)
1231  return CNTV2DriverInterface::ReadRegister(kRegGlobalControl3, outValue, kRegMaskQuadQuadMode, kRegShiftQuadQuadMode);
1232  else
1233  return CNTV2DriverInterface::ReadRegister(kRegGlobalControl3, outValue, kRegMaskQuadQuadMode2, kRegShiftQuadQuadMode2);
1234  }
1235  return true;
1236 }
1237 
1238 bool CNTV2Card::Set4kSquaresEnable (const bool inEnable, NTV2Channel inChannel)
1239 {
1240  bool status = true;
1241 
1242  if (!IsSupported(kDeviceCanDo4KVideo))
1243  return false;
1244  if (IsMultiRasterWidgetChannel(inChannel))
1245  return inEnable == true;
1246  if (!NTV2_IS_VALID_CHANNEL(inChannel))
1247  return false;
1248 
1249  if (inEnable)
1250  {
1251  // enable quad frame, disable 425
1252  if (!IsMultiFormatActive())
1253  status = WriteRegister(kRegGlobalControl2, 1, kRegMaskQuadMode, kRegShiftQuadMode) &&
1254  WriteRegister(kRegGlobalControl2, 1, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1255  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB12, kRegShift425FB12) &&
1256  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB34, kRegShift425FB34) &&
1257  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB56, kRegShift425FB56) &&
1258  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB78, kRegShift425FB78) &&
1259  WriteRegister(kRegGlobalControl, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1260  WriteRegister(kRegGlobalControlCh2, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1261  WriteRegister(kRegGlobalControlCh3, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1262  WriteRegister(kRegGlobalControlCh4, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1263  CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL8);
1264  else if (inChannel < NTV2_CHANNEL5)
1265  status = WriteRegister (kRegGlobalControl2, 1, kRegMaskQuadMode, kRegShiftQuadMode) &&
1266  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB12, kRegShift425FB12) &&
1267  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB34, kRegShift425FB34) &&
1268  CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL4);
1269  else
1270  status = WriteRegister(kRegGlobalControl2, 1, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1271  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB56, kRegShift425FB56) &&
1272  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB78, kRegShift425FB78) &&
1273  CopyVideoFormat(inChannel, NTV2_CHANNEL5, NTV2_CHANNEL8);
1274  }
1275  else
1276  {
1277  if (!IsMultiFormatActive())
1278  status = WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode) &&
1279  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2);
1280  else if (inChannel < NTV2_CHANNEL5)
1281  status = WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode);
1282  else
1283  status = WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2);
1284  }
1285 
1286  return status;
1287 }
1288 
1289 bool CNTV2Card::Get4kSquaresEnable (bool & outIsEnabled, const NTV2Channel inChannel)
1290 {
1291  outIsEnabled = false;
1292  if (IsMultiRasterWidgetChannel(inChannel))
1293  {outIsEnabled = true; return true;}
1294  if (!NTV2_IS_VALID_CHANNEL(inChannel))
1295  return false;
1296  ULWord squaresEnabled (0);
1297  bool status = true;
1298 
1299  if (inChannel < NTV2_CHANNEL5)
1300  status = ReadRegister (kRegGlobalControl2, squaresEnabled, kRegMaskQuadMode, kRegShiftQuadMode);
1301  else
1302  status = ReadRegister(kRegGlobalControl2, squaresEnabled, kRegMaskQuadMode2, kRegShiftQuadMode2);
1303 
1304  outIsEnabled = (squaresEnabled ? true : false);
1305  return status;
1306 }
1307 
1308 // Method: SetTsiFrameEnable
1309 // Input: bool
1310 // Output: NONE
1311 bool CNTV2Card::SetTsiFrameEnable (const bool enable, const NTV2Channel inChannel)
1312 {
1313  bool status = true;
1314 
1315  if (!IsSupported(kDeviceCanDo425Mux) && !IsSupported(kDeviceCanDo12gRouting))
1316  return false;
1317  if (IsMultiRasterWidgetChannel(inChannel))
1318  return enable == true;
1319  if (!NTV2_IS_VALID_CHANNEL(inChannel))
1320  return false;
1321 
1322  if (enable)
1323  {
1324  if (IsSupported(kDeviceCanDo12gRouting))
1325  {
1326  status = WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode) &&
1327  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1328  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB12, kRegShift425FB12) &&
1329  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB34, kRegShift425FB34) &&
1330  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB56, kRegShift425FB56) &&
1331  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB78, kRegShift425FB78);
1332  if (!status)
1333  return false;
1334 
1335  if (!IsMultiFormatActive())
1336  status = WriteRegister(kRegGlobalControl, 1, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1337  WriteRegister(kRegGlobalControlCh2, 1, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1338  WriteRegister(kRegGlobalControlCh3, 1, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1339  WriteRegister(kRegGlobalControlCh4, 1, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1340  CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL8);
1341  else
1342  status = WriteRegister(gChannelToGlobalControlRegNum[inChannel], 1, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable);
1343  }
1344  // enable 425 mode, disable squares
1345  else if (!IsMultiFormatActive())
1346  status = WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode) &&
1347  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1348  WriteRegister(kRegGlobalControl2, 1, kRegMask425FB12, kRegShift425FB12) &&
1349  WriteRegister(kRegGlobalControl2, 1, kRegMask425FB34, kRegShift425FB34) &&
1350  WriteRegister(kRegGlobalControl2, 1, kRegMask425FB56, kRegShift425FB56) &&
1351  WriteRegister(kRegGlobalControl2, 1, kRegMask425FB78, kRegShift425FB78) &&
1352  CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL8);
1353  else if (inChannel < NTV2_CHANNEL3)
1354  status = WriteRegister(kRegGlobalControl2, 1, kRegMask425FB12, kRegShift425FB12) &&
1355  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode) &&
1356  CopyVideoFormat(inChannel, NTV2_CHANNEL1, NTV2_CHANNEL2);
1357  else if (inChannel < NTV2_CHANNEL5)
1358  status = WriteRegister(kRegGlobalControl2, 1, kRegMask425FB34, kRegShift425FB34) &&
1359  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode, kRegShiftQuadMode) &&
1360  CopyVideoFormat(inChannel, NTV2_CHANNEL3, NTV2_CHANNEL4);
1361  else if (inChannel < NTV2_CHANNEL7)
1362  status = WriteRegister(kRegGlobalControl2, 1, kRegMask425FB56, kRegShift425FB56) &&
1363  WriteRegister(kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1364  CopyVideoFormat(inChannel, NTV2_CHANNEL5, NTV2_CHANNEL6);
1365  else
1366  status = WriteRegister(kRegGlobalControl2, 1, kRegMask425FB78, kRegShift425FB78) &&
1367  WriteRegister (kRegGlobalControl2, 0, kRegMaskQuadMode2, kRegShiftQuadMode2) &&
1368  CopyVideoFormat(inChannel, NTV2_CHANNEL7, NTV2_CHANNEL8);
1369  }
1370  else
1371  {
1372  if (IsSupported(kDeviceCanDo12gRouting))
1373  {
1374  if (!IsMultiFormatActive())
1375  status = WriteRegister(kRegGlobalControl, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1376  WriteRegister(kRegGlobalControlCh2, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1377  WriteRegister(kRegGlobalControlCh3, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable) &&
1378  WriteRegister(kRegGlobalControlCh4, 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable);
1379  else
1380  status = WriteRegister(gChannelToGlobalControlRegNum[inChannel], 0, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable);
1381  }
1382  // disable 425 mode, enable squares
1383  else if (!IsMultiFormatActive())
1384  status = WriteRegister(kRegGlobalControl2, 0, kRegMask425FB12, kRegShift425FB12) &&
1385  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB34, kRegShift425FB34) &&
1386  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB56, kRegShift425FB56) &&
1387  WriteRegister(kRegGlobalControl2, 0, kRegMask425FB78, kRegShift425FB78);
1388  else if (inChannel < NTV2_CHANNEL3)
1389  status = WriteRegister(kRegGlobalControl2, 0, kRegMask425FB12, kRegShift425FB12);
1390  else if (inChannel < NTV2_CHANNEL5)
1391  status = WriteRegister(kRegGlobalControl2, 0, kRegMask425FB34, kRegShift425FB34);
1392  else if (inChannel < NTV2_CHANNEL7)
1393  status = WriteRegister(kRegGlobalControl2, 0, kRegMask425FB56, kRegShift425FB56);
1394  else
1395  status = WriteRegister(kRegGlobalControl2, 0, kRegMask425FB78, kRegShift425FB78);
1396  }
1397 
1398  return status;
1399 }
1400 
1401 // Method: GetTsiFrameEnable
1402 // Input: NONE
1403 // Output: bool
1404 bool CNTV2Card::GetTsiFrameEnable (bool & outIsEnabled, const NTV2Channel inChannel)
1405 {
1406  outIsEnabled = false;
1407  if (!IsSupported(kDeviceCanDo425Mux) && !IsSupported(kDeviceCanDo12gRouting))
1408  return false;
1409  if (IsMultiRasterWidgetChannel(inChannel))
1410  {outIsEnabled = true; return true;}
1411  if (!NTV2_IS_VALID_CHANNEL(inChannel))
1412  return false;
1413  // Return true (1) Quad Frame Geometry is enabled
1414  // Return false (0) if this mode is disabled
1415  bool returnVal(false), readOkay(false);
1416 
1417  if (IsSupported(kDeviceCanDo12gRouting))
1418  {
1419  readOkay = GetQuadQuadFrameEnable(returnVal, inChannel);
1420  if (!returnVal)
1421  readOkay = CNTV2DriverInterface::ReadRegister(gChannelToGlobalControlRegNum[inChannel], returnVal, kRegMaskQuadTsiEnable, kRegShiftQuadTsiEnable);
1422  }
1423  else
1424  {
1425  if (inChannel < NTV2_CHANNEL3)
1426  readOkay = CNTV2DriverInterface::ReadRegister (kRegGlobalControl2, returnVal, kRegMask425FB12, kRegShift425FB12);
1427  else if (inChannel < NTV2_CHANNEL5)
1428  readOkay = CNTV2DriverInterface::ReadRegister (kRegGlobalControl2, returnVal, kRegMask425FB34, kRegShift425FB34);
1429  else if (inChannel < NTV2_CHANNEL7)
1430  readOkay = CNTV2DriverInterface::ReadRegister (kRegGlobalControl2, returnVal, kRegMask425FB56, kRegShift425FB56);
1431  else
1432  readOkay = CNTV2DriverInterface::ReadRegister(kRegGlobalControl2, returnVal, kRegMask425FB78, kRegShift425FB78);
1433  }
1434 
1435  outIsEnabled = readOkay ? returnVal : 0;
1436  return readOkay;
1437 }
1438 
1439 bool CNTV2Card::GetTsiMuxSyncFail (bool & outSyncFailed, const NTV2Channel inWhichTsiMux)
1440 {
1441  ULWord value(0);
1442  outSyncFailed = false;
1443  if (!IsSupported(kDeviceCanDo425Mux))
1444  return false;
1445  if (!NTV2_IS_VALID_CHANNEL(inWhichTsiMux))
1446  return false;
1447  if (!ReadRegister(kRegSDIInput3GStatus, value, kRegMaskSDIInTsiMuxSyncFail, kRegShiftSDIInTsiMuxSyncFail))
1448  return false;
1449  if (value & (1<<inWhichTsiMux))
1450  outSyncFailed = true;
1451  return true;
1452 }
1453 
1454 bool CNTV2Card::CopyVideoFormat(const NTV2Channel inSrc, const NTV2Channel inFirst, const NTV2Channel inLast)
1455 {
1456  ULWord standard(0), rate1(0), rate2(0), s372(0), geometry(0), format(0);
1457  bool status(false);
1458 
1459  status = ReadRegister (gChannelToGlobalControlRegNum[inSrc], standard, kRegMaskStandard, kRegShiftStandard);
1460  status &= ReadRegister (gChannelToGlobalControlRegNum[inSrc], rate1, kRegMaskFrameRate, kRegShiftFrameRate);
1461  status &= ReadRegister (gChannelToGlobalControlRegNum[inSrc], rate2, kRegMaskFrameRateHiBit, kRegShiftFrameRateHiBit);
1462  status &= ReadRegister (gChannelToSmpte372RegisterNum[inSrc], s372, gChannelToSmpte372Masks[inSrc], gChannelToSmpte372Shifts[inSrc]);
1463  status &= ReadRegister (gChannelToGlobalControlRegNum[inSrc], geometry, kRegMaskGeometry, kRegShiftGeometry);
1464  status &= ReadRegister (kVRegVideoFormatCh1 + inSrc, format);
1465  if (!status) return false;
1466 
1467  for (int channel = inFirst; channel <= inLast; channel++)
1468  {
1469  status = WriteRegister (gChannelToGlobalControlRegNum[channel], standard, kRegMaskStandard, kRegShiftStandard);
1470  status &= WriteRegister (gChannelToGlobalControlRegNum[channel], rate1, kRegMaskFrameRate, kRegShiftFrameRate);
1471  status &= WriteRegister (gChannelToGlobalControlRegNum[channel], rate2, kRegMaskFrameRateHiBit, kRegShiftFrameRateHiBit);
1472  status &= WriteRegister (gChannelToSmpte372RegisterNum[channel], s372, gChannelToSmpte372Masks[channel], gChannelToSmpte372Shifts[channel]);
1473  status &= WriteRegister (gChannelToGlobalControlRegNum[channel], geometry, kRegMaskGeometry, kRegShiftGeometry);
1474  status &= WriteRegister (ULWord(kVRegVideoFormatCh1 + channel), format);
1475  if (!status) return false;
1476  }
1477 
1478  return true;
1479 }
1480 
1481 // Method: SetReference
1482 // Input: NTV2Reference
1483 // Output: NONE
1484 bool CNTV2Card::SetReference (const NTV2ReferenceSource inRefSource, const bool inKeepFramePulseSelect)
1485 {
1486  if (IsSupported(kDeviceCanDoLTCInOnRefPort) && inRefSource == NTV2_REFERENCE_EXTERNAL)
1487  SetLTCInputEnable(false);
1488 
1489  if (IsSupported(kDeviceCanDoFramePulseSelect) && !inKeepFramePulseSelect)
1490  EnableFramePulseReference(false); //Reset this for backwards compatibility
1491 
1492  //this looks slightly unusual but really
1493  //it is a 4 bit counter in 2 different registers
1494  ULWord refControl1 = ULWord(inRefSource), refControl2 = 0, ptpControl = 0;
1495  switch (inRefSource)
1496  {
1497  case NTV2_REFERENCE_INPUT5: refControl1 = 0; refControl2 = 1; break;
1498  case NTV2_REFERENCE_INPUT6: refControl1 = 1; refControl2 = 1; break;
1499  case NTV2_REFERENCE_INPUT7: refControl1 = 2; refControl2 = 1; break;
1500  case NTV2_REFERENCE_INPUT8: refControl1 = 3; refControl2 = 1; break;
1501  case NTV2_REFERENCE_SFP1_PCR: refControl1 = 4; refControl2 = 1; break;
1502  case NTV2_REFERENCE_SFP1_PTP: refControl1 = 4; refControl2 = 1; ptpControl = 1; break;
1503  case NTV2_REFERENCE_SFP2_PCR: refControl1 = 5; refControl2 = 1; break;
1504  case NTV2_REFERENCE_SFP2_PTP: refControl1 = 5; refControl2 = 1; ptpControl = 1; break;
1505  case NTV2_REFERENCE_HDMI_INPUT2: refControl1 = 4; refControl2 = 0; break;
1506  case NTV2_REFERENCE_HDMI_INPUT3: refControl1 = 6; refControl2 = 0; break;
1507  case NTV2_REFERENCE_HDMI_INPUT4: refControl1 = 7; refControl2 = 0; break;
1508  default: break;
1509  }
1510 
1511  if (IsIPDevice())
1512  WriteRegister(kRegGlobalControl2, ptpControl, kRegMaskPCRReferenceEnable, kRegShiftPCRReferenceEnable);
1513 
1514  if (GetNumSupported(kDeviceGetNumVideoChannels) > 4 || (IsIPDevice() || Is25GIPDevice()) )
1515  WriteRegister (kRegGlobalControl2, refControl2, kRegMaskRefSource2, kRegShiftRefSource2);
1516 
1517  return WriteRegister (kRegGlobalControl, refControl1, kRegMaskRefSource, kRegShiftRefSource);
1518 }
1519 
1520 // Method: GetReference
1521 // Input: NTV2Reference
1522 // Output: NONE
1523 bool CNTV2Card::GetReference (NTV2ReferenceSource & outValue)
1524 {
1525  ULWord refControl2(0), ptpControl(0);
1526  bool result (CNTV2DriverInterface::ReadRegister (kRegGlobalControl, outValue, kRegMaskRefSource, kRegShiftRefSource));
1527 
1528  if ((GetNumSupported(kDeviceGetNumVideoChannels) > 4 || IsIPDevice()) && !NTV2DeviceCanDo25GIP(_boardID) )
1529  {
1530  ReadRegister (kRegGlobalControl2, refControl2, kRegMaskRefSource2, kRegShiftRefSource2);
1531  if (refControl2)
1532  switch (outValue)
1533  {
1534  case 0: outValue = NTV2_REFERENCE_INPUT5; break;
1535  case 1: outValue = NTV2_REFERENCE_INPUT6; break;
1536  case 2: outValue = NTV2_REFERENCE_INPUT7; break;
1537  case 3: outValue = NTV2_REFERENCE_INPUT8; break;
1538 
1539  case 4: if (IsIPDevice())
1540  ReadRegister (kRegGlobalControl2, ptpControl, kRegMaskPCRReferenceEnable, kRegShiftPCRReferenceEnable);
1541  outValue = ptpControl == 0 ? NTV2_REFERENCE_SFP1_PCR : NTV2_REFERENCE_SFP1_PTP;
1542  break;
1543 
1544  case 5: if (IsIPDevice())
1545  ReadRegister (kRegGlobalControl2, ptpControl, kRegMaskPCRReferenceEnable, kRegShiftPCRReferenceEnable);
1546  outValue = ptpControl == 0 ? NTV2_REFERENCE_SFP2_PCR : NTV2_REFERENCE_SFP2_PTP;
1547  break;
1548 
1549  default: break;
1550  }
1551  }
1552 
1553  if (NTV2DeviceCanDo25GIP(_boardID))
1554  {
1555  result = ReadRegister(kRegLPPTPSFPStatus, ptpControl);
1556  switch(ptpControl)
1557  {
1558  default:
1559  case 0:
1560  outValue = NTV2_REFERENCE_FREERUN;
1561  break;
1562  case 1:
1563  outValue = NTV2_REFERENCE_SFP1_PTP;
1564  break;
1565  case 2:
1566  outValue = NTV2_REFERENCE_SFP2_PTP;
1567  break;
1568  }
1569  }
1570 
1571  if (_boardID == DEVICE_ID_KONAHDMI)
1572  switch (outValue)
1573  {
1574  case 5: outValue = NTV2_REFERENCE_HDMI_INPUT1; break;
1575  case 4: outValue = NTV2_REFERENCE_HDMI_INPUT2; break;
1576  case 6: outValue = NTV2_REFERENCE_HDMI_INPUT3; break;
1577  case 7: outValue = NTV2_REFERENCE_HDMI_INPUT4; break;
1578  default: break;
1579  }
1580 
1581  return result;
1582 }
1583 
1584 bool CNTV2Card::EnableFramePulseReference (const bool enable)
1585 {
1586  if (!IsSupported(kDeviceCanDoFramePulseSelect))
1587  return false;
1588 
1589  return WriteRegister (kRegGlobalControl3, enable ? 1 : 0, kRegMaskFramePulseEnable, kRegShiftFramePulseEnable);
1590 }
1591 
1592 
1593 bool CNTV2Card::GetEnableFramePulseReference (bool & outValue)
1594 {
1595  if (!IsSupported(kDeviceCanDoFramePulseSelect))
1596  return false;
1597 
1598  ULWord returnValue(0);
1599  bool status = ReadRegister(kRegGlobalControl3, returnValue, kRegMaskFramePulseEnable, kRegShiftFramePulseEnable);
1600  outValue = returnValue == 0 ? false : true;
1601  return status;
1602 }
1603 
1604 bool CNTV2Card::SetFramePulseReference (const NTV2ReferenceSource value)
1605 {
1606  if (!IsSupported(kDeviceCanDoFramePulseSelect))
1607  return false;
1608  return WriteRegister (kRegGlobalControl3, ULWord(value), kRegMaskFramePulseRefSelect, kRegShiftFramePulseRefSelect);
1609 }
1610 
1611 bool CNTV2Card::GetFramePulseReference (NTV2ReferenceSource & outValue)
1612 {
1613  ULWord refControl1(0);
1614  if (!IsSupported(kDeviceCanDoFramePulseSelect))
1615  return false;
1616 
1617  bool result (ReadRegister (kRegGlobalControl3, refControl1, kRegMaskFramePulseRefSelect, kRegShiftFramePulseRefSelect));
1618  outValue = NTV2ReferenceSource(refControl1);
1619  return result;
1620 }
1621 
1622 // Method: SetMode
1623 // Input: NTV2Channel, NTV2Mode
1624 // Output: NONE
1625 bool CNTV2Card::SetMode (const NTV2Channel inChannel, const NTV2Mode inValue, const bool inIsRetail)
1626 { (void) inIsRetail;
1627  if (IsMultiRasterWidgetChannel(inChannel))
1628  return inValue == NTV2_MODE_INPUT;
1629  if (IS_CHANNEL_INVALID(inChannel))
1630  return false;
1631  return WriteRegister (gChannelToControlRegNum[inChannel], inValue, kRegMaskMode, kRegShiftMode);
1632 }
1633 
1634 bool CNTV2Card::SetMode (const NTV2ChannelSet & inChannels, const NTV2Mode inMode)
1635 {
1636  size_t errors(0);
1637  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
1638  if (!SetMode(*it, inMode))
1639  errors++;
1640  return !errors;
1641 }
1642 
1643 bool CNTV2Card::GetMode (const NTV2Channel inChannel, NTV2Mode & outValue)
1644 {
1645  if (IsMultiRasterWidgetChannel(inChannel))
1646  {outValue = NTV2_MODE_INPUT; return true;}
1647  if (IS_CHANNEL_INVALID(inChannel))
1648  return false;
1649  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskMode, kRegShiftMode);
1650 }
1651 
1652 bool CNTV2Card::GetFrameInfo (const NTV2Channel inChannel, NTV2FrameGeometry & outGeometry, NTV2FrameBufferFormat & outFBF)
1653 {
1654  bool status = GetFrameGeometry(outGeometry); // WHY ISN'T inChannel PASSED TO GetFrameGeometry?!?!?!
1655  if ( !status )
1656  return status; // TODO: fix me
1657 
1658  status = GetFrameBufferFormat(inChannel, outFBF);
1659  if ( !status )
1660  return status; // TODO: fix me
1661 
1662  return status;
1663 }
1664 
1665 bool CNTV2Card::IsBufferSizeChangeRequired(NTV2Channel channel, NTV2FrameGeometry currentGeometry, NTV2FrameGeometry newGeometry,
1666  NTV2FrameBufferFormat format)
1667 {
1668  (void) channel;
1669  ULWord currentFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,currentGeometry,format);
1670  ULWord requestedFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,newGeometry,format);
1671  bool changeBufferSize = IsSupported(kDeviceCanChangeFrameBufferSize) && (currentFrameBufferSize != requestedFrameBufferSize);
1672 
1673  // If software has decreed a frame buffer size, don't try to change it
1674  if (IsBufferSizeSetBySW())
1675  changeBufferSize = false;
1676 
1677  return changeBufferSize;
1678 }
1679 
1680 bool CNTV2Card::IsBufferSizeChangeRequired(NTV2Channel channel, NTV2FrameGeometry geometry,
1681  NTV2FrameBufferFormat currentFormat, NTV2FrameBufferFormat newFormat)
1682 {
1683  (void)channel;
1684 
1685  ULWord currentFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,currentFormat);
1686  ULWord requestedFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,newFormat);
1687  bool changeBufferSize = IsSupported(kDeviceCanChangeFrameBufferSize) && (currentFrameBufferSize != requestedFrameBufferSize);
1688 
1689  // If software has decreed a frame buffer size, don't try to change it
1690  if (IsBufferSizeSetBySW())
1691  changeBufferSize = false;
1692 
1693  return changeBufferSize;
1694 }
1695 
1696 bool CNTV2Card::IsBufferSizeSetBySW (void)
1697 {
1698  if (!::NTV2DeviceSoftwareCanChangeFrameBufferSize(_boardID))
1699  return false;
1700 
1701  ULWord swControl(0);
1702  if (!ReadRegister(kRegCh1Control, swControl, kRegMaskFrameSizeSetBySW, kRegShiftFrameSizeSetBySW))
1703  return false;
1704 
1705  return swControl != 0;
1706 }
1707 
1708 bool CNTV2Card::GetFBSizeAndCountFromHW (ULWord & outSize, ULWord & outCount)
1709 {
1710  if (!IsBufferSizeSetBySW())
1711  return false;
1712 
1713  ULWord ch1Control(0), multiplier(0), sizeMultiplier(0);
1714  if (!ReadRegister(kRegCh1Control, ch1Control))
1715  return false;
1716 
1717  ch1Control &= BIT_20 | BIT_21;
1718  switch (ch1Control)
1719  {
1720  default:
1721  case 0: multiplier = 4; // 2MB frame buffers
1722  sizeMultiplier = 2;
1723  break;
1724 
1725  case BIT_20: multiplier = 2; // 4MB
1726  sizeMultiplier = 4;
1727  break;
1728 
1729  case BIT_21: multiplier = 1; // 8MB
1730  sizeMultiplier = 8;
1731  break;
1732 
1733  case BIT_20 | BIT_21: multiplier = 0; // 16MB
1734  sizeMultiplier = 16;
1735  break;
1736  }
1737 
1738  outSize = sizeMultiplier * 1024 * 1024;
1739  outCount = multiplier ? multiplier * DeviceGetNumberFrameBuffers() : DeviceGetNumberFrameBuffers() / 2;
1740 
1741  NTV2FrameGeometry geometry(NTV2_FG_INVALID);
1742  GetFrameGeometry(geometry);
1743  if (geometry == NTV2_FG_4x1920x1080 || geometry == NTV2_FG_4x2048x1080)
1744  {
1745  outSize *= 4;
1746  outCount /= 4;
1747  }
1748  if (geometry == NTV2_FG_4x3840x2160 || geometry == NTV2_FG_4x4096x2160)
1749  {
1750  outSize *= 16;
1751  outCount /= 16;
1752  }
1753  return true;
1754 }
1755 
1756 bool CNTV2Card::SetFrameBufferSize (const NTV2Framesize inSize)
1757 {
1758  ULWord reg1Contents;
1759 
1760  if (!::NTV2DeviceSoftwareCanChangeFrameBufferSize(_boardID))
1761  return false;
1762 
1763  if (!ReadRegister(kRegCh1Control, reg1Contents))
1764  return false;
1765 
1766  reg1Contents |= kRegMaskFrameSizeSetBySW;
1767  reg1Contents &= ~kK2RegMaskFrameSize;
1768  reg1Contents |= ULWord(inSize) << kK2RegShiftFrameSize;
1769 
1770  if (!WriteRegister(kRegCh1Control, reg1Contents))
1771  return false;
1772 
1773  return GetFBSizeAndCountFromHW(_ulFrameBufferSize, _ulNumFrameBuffers);
1774 }
1775 
1776 bool CNTV2Card::GetLargestFrameBufferFormatInUse(NTV2FrameBufferFormat & outFBF)
1777 {
1778  NTV2FrameBufferFormat ch1format;
1779  NTV2FrameBufferFormat ch2format = NTV2_FBF_8BIT_YCBCR;
1780 
1781  if ( !GetFrameBufferFormat(NTV2_CHANNEL1, ch1format) )
1782  return false;
1783 
1784  if ( !GetFrameBufferFormat(NTV2_CHANNEL2, ch2format) &&
1785  GetNumSupported(kDeviceGetNumVideoChannels) > 1)
1786  return false;
1787 
1788  NTV2FrameGeometry geometry;
1789  if (!GetFrameGeometry(geometry))
1790  return false;
1791 
1792  ULWord ch1FrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,ch1format);
1793  ULWord ch2FrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,ch2format);
1794  if ( ch1FrameBufferSize >= ch2FrameBufferSize )
1795  outFBF = ch1format;
1796  else
1797  outFBF = ch2format;
1798  return true;
1799 }
1800 
1801 bool CNTV2Card::IsMultiFormatActive (void)
1802 {
1803  if (!IsSupported(kDeviceCanDoMultiFormat))
1804  return false;
1805 
1806  bool isEnabled = false;
1807  if (!GetMultiFormatMode (isEnabled))
1808  return false;
1809 
1810  return isEnabled;
1811 }
1812 
1813 bool CNTV2Card::GetPossibleConnections (NTV2PossibleConnections & outConnections)
1814 {
1815  outConnections.clear();
1816  if (!IsSupported(kDeviceHasXptConnectROM))
1817  return false;
1818 
1819  NTV2RegReads ROMregs;
1820  return CNTV2SignalRouter::MakeRouteROMRegisters(ROMregs)
1821  && ReadRegisters(ROMregs)
1822  && CNTV2SignalRouter::GetPossibleConnections(ROMregs, outConnections);
1823 }
1824 
1825 bool CNTV2Card::GetAllWidgetInputs (NTV2InputXptIDSet & outInputs)
1826 {
1827  outInputs.clear();
1828  const ULWordSet widgetIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
1829 
1830  for (ULWordSetConstIter iter(widgetIDs.begin()); iter != widgetIDs.end (); ++iter)
1831  {
1832  const NTV2WidgetID wgtID(NTV2WidgetID(*iter + 0));
1833  NTV2InputXptIDSet inputs;
1834  CNTV2SignalRouter::GetWidgetInputs (wgtID, inputs);
1835  for (NTV2InputXptIDSetConstIter it(inputs.begin()); it != inputs.end(); ++it)
1836  {
1837  if (CNTV2SignalRouter::WidgetIDToType(wgtID) == NTV2WidgetType_FrameStore)
1838  if (!IsSupported(kDeviceCanDo425Mux))
1839  if (!IsSupported(kDeviceCanDo8KVideo))
1840  if (::NTV2InputCrosspointIDToString(*it, false).find("DS2") != string::npos) // is DS2 input?
1841  continue; // do not include FrameStore DS2 inputs for IP25G
1842  outInputs.insert(*it);
1843  }
1844  }
1845  return true;
1846 }
1847 
1848 bool CNTV2Card::GetAllWidgetOutputs (NTV2OutputXptIDSet & outOutputs)
1849 {
1850  outOutputs.clear();
1851  const ULWordSet widgetIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
1852 
1853  for (ULWordSetConstIter iter(widgetIDs.begin()); iter != widgetIDs.end (); ++iter)
1854  {
1855  const NTV2WidgetID wgtID(NTV2WidgetID(*iter + 0));
1856  NTV2OutputXptIDSet outputs;
1857  CNTV2SignalRouter::GetWidgetOutputs (wgtID, outputs);
1858  for (NTV2OutputXptIDSetConstIter it(outputs.begin()); it != outputs.end(); ++it)
1859  {
1860  if (CNTV2SignalRouter::WidgetIDToType(wgtID) == NTV2WidgetType_FrameStore)
1861  if (!IsSupported(kDeviceCanDo425Mux))
1862  if (!IsSupported(kDeviceCanDo8KVideo))
1863  if (::NTV2OutputCrosspointIDToString(*it, false).find("DS2") != string::npos) // is DS2 output?
1864  continue; // do not include FrameStore DS2 outputs for IP25G
1865  outOutputs.insert(*it);
1866  }
1867  }
1868  return true;
1869 }
1870 
1872 
1873 // Method: SetFrameBufferFormat
1874 // Input: NTV2Channel, NTV2FrameBufferFormat
1875 // Output: NONE
1876 bool CNTV2Card::SetFrameBufferFormat (NTV2Channel inChannel, NTV2FrameBufferFormat inNewFormat, bool inIsRetailMode,
1877  NTV2HDRXferChars inXferChars, NTV2HDRColorimetry inColorimetry, NTV2HDRLuminance inLuminance)
1878 { (void) inIsRetailMode;
1879 
1880  if (IsMultiRasterWidgetChannel(inChannel))
1881  return inNewFormat == NTV2_FBF_8BIT_YCBCR;
1882  if (IS_CHANNEL_INVALID(inChannel))
1883  return false;
1884 
1885  const ULWord regNum (gChannelToControlRegNum[inChannel]);
1886  const ULWord loValue (inNewFormat & 0x0f);
1887  const ULWord hiValue ((inNewFormat & 0x10) >> 4);
1888  NTV2FrameGeometry currentGeometry (NTV2_FG_INVALID);
1889  NTV2FrameBufferFormat currentFormat (NTV2_FBF_INVALID); // save for call to IsBufferSizeChangeRequired below
1890  bool status = GetFrameInfo(inChannel, currentGeometry, currentFormat);
1891  if (!status)
1892  return status;
1893 
1894  // Set channel control register FBF bits 1,2,3,4,6...
1895  status = WriteRegister (regNum, loValue, kRegMaskFrameFormat, kRegShiftFrameFormat)
1896  && WriteRegister (regNum, hiValue, kRegMaskFrameFormatHiBit, kRegShiftFrameFormatHiBit);
1897 
1898  // If software set the frame buffer size, read the values from hardware
1899  if ( !GetFBSizeAndCountFromHW(_ulFrameBufferSize, _ulNumFrameBuffers) &&
1900  IsBufferSizeChangeRequired(inChannel, currentGeometry, currentFormat, inNewFormat) )
1901  {
1902  _ulFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,currentGeometry, inNewFormat);
1903  _ulNumFrameBuffers = ::NTV2DeviceGetNumberFrameBuffers(_boardID,currentGeometry, inNewFormat);
1904  }
1905 
1906  if (status)
1907  {if (inNewFormat != currentFormat)
1908  CVIDINFO("'" << GetDisplayName() << "': Channel " << DEC(UWord(inChannel)+1) << " FBF changed from "
1909  << ::NTV2FrameBufferFormatToString(currentFormat) << " to "
1910  << ::NTV2FrameBufferFormatToString(inNewFormat) << " (FBSize=" << xHEX0N(_ulFrameBufferSize,8)
1911  << " numFBs=" << DEC(_ulNumFrameBuffers) << ")");}
1912  else
1913  CVIDFAIL("'" << GetDisplayName() << "': Failed to change channel " << DEC(UWord(inChannel)+1) << " FBF from "
1914  << ::NTV2FrameBufferFormatToString(currentFormat) << " to " << ::NTV2FrameBufferFormatToString(inNewFormat));
1915 
1916  SetVPIDTransferCharacteristics(inXferChars, inChannel);
1917  SetVPIDColorimetry(inColorimetry, inChannel);
1918  SetVPIDLuminance(inLuminance, inChannel);
1919  return status;
1920 }
1921 
1922 bool CNTV2Card::SetFrameBufferFormat (const NTV2ChannelSet & inFrameStores,
1923  const NTV2FrameBufferFormat inNewFormat,
1924  const bool inIsAJARetail,
1925  const NTV2HDRXferChars inXferChars,
1926  const NTV2HDRColorimetry inColorimetry,
1927  const NTV2HDRLuminance inLuminance)
1928 {
1929  UWord failures(0);
1930  for (NTV2ChannelSetConstIter it(inFrameStores.begin()); it != inFrameStores.end(); ++it)
1931  if (!SetFrameBufferFormat (*it, inNewFormat, inIsAJARetail, inXferChars, inColorimetry, inLuminance))
1932  failures++;
1933  return failures == 0;
1934 }
1935 
1936 // Method: GetFrameBufferFormat
1937 // Input: NTV2Channel
1938 // Output: NTV2FrameBufferFormat
1939 bool CNTV2Card::GetFrameBufferFormat (NTV2Channel inChannel, NTV2FrameBufferFormat & outValue)
1940 {
1941  if (IsMultiRasterWidgetChannel(inChannel))
1942  {outValue = NTV2_FBF_8BIT_YCBCR; return true;}
1943  if (IS_CHANNEL_INVALID (inChannel))
1944  return false;
1945 
1946  ULWord returnVal1, returnVal2;
1947  bool result1 = ReadRegister (gChannelToControlRegNum[inChannel], returnVal1, kRegMaskFrameFormat, kRegShiftFrameFormat);
1948  bool result2 = ReadRegister (gChannelToControlRegNum[inChannel], returnVal2, kRegMaskFrameFormatHiBit, kRegShiftFrameFormatHiBit);
1949 
1950  outValue = NTV2FrameBufferFormat((returnVal1 & 0x0f) | ((returnVal2 & 0x1) << 4));
1951  return result1 && result2;
1952 }
1953 
1954 // Method: SetFrameBufferQuarterSizeMode
1955 // Input: NTV2Channel, NTV2K2QuarterSizeExpandMode
1956 // Output: NONE
1957 bool CNTV2Card::SetFrameBufferQuarterSizeMode (NTV2Channel channel, NTV2QuarterSizeExpandMode value)
1958 {
1959  if (IS_CHANNEL_INVALID (channel))
1960  return false;
1961  return WriteRegister (gChannelToControlRegNum [channel], value, kRegMaskQuarterSizeMode, kRegShiftQuarterSizeMode);
1962 }
1963 
1964 // Method: GetFrameBufferQuarterSizeMode
1965 // Input: NTV2Channel
1966 // Output: NTV2K2QuarterSizeExpandMode
1967 bool CNTV2Card::GetFrameBufferQuarterSizeMode (NTV2Channel inChannel, NTV2QuarterSizeExpandMode & outValue)
1968 {
1969  if (IS_CHANNEL_INVALID (inChannel))
1970  return false;
1971  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskQuarterSizeMode, kRegShiftQuarterSizeMode);
1972 }
1973 
1974 // Method: SetFrameBufferQuality - currently used for ProRes compressed buffers
1975 // Input: NTV2Channel, NTV2K2FrameBufferQuality
1976 // Output: NONE
1977 bool CNTV2Card::SetFrameBufferQuality (NTV2Channel channel, NTV2FrameBufferQuality quality)
1978 {
1979  if (IS_CHANNEL_INVALID (channel))
1980  return false;
1981  // note buffer quality is split between bit 17 (lo), 25-26 (hi)
1982  ULWord loValue = quality & 0x1;
1983  ULWord hiValue = (quality >> 1) & 0x3;
1984  return WriteRegister (gChannelToControlRegNum [channel], loValue, kRegMaskQuality, kRegShiftQuality) &&
1985  WriteRegister (gChannelToControlRegNum [channel], hiValue, kRegMaskQuality2, kRegShiftQuality2);
1986 }
1987 
1988 // Method: GetFrameBufferQuality - currently used for ProRes compressed buffers
1989 // Input: NTV2Channel
1990 // Output: NTV2K2FrameBufferQuality
1991 bool CNTV2Card::GetFrameBufferQuality (NTV2Channel inChannel, NTV2FrameBufferQuality & outQuality)
1992 {
1993  if (IS_CHANNEL_INVALID (inChannel))
1994  return false;
1995  outQuality = NTV2_FBQualityInvalid;
1996  // note buffer quality is split between bit 17 (lo), 25-26 (hi)
1997  ULWord loValue(0), hiValue(0);
1998  if (ReadRegister (gChannelToControlRegNum [inChannel], loValue, kRegMaskQuality, kRegShiftQuality) &&
1999  ReadRegister (gChannelToControlRegNum [inChannel], hiValue, kRegMaskQuality2, kRegShiftQuality2))
2000  {
2001  outQuality = NTV2FrameBufferQuality(loValue + ((hiValue & 0x3) << 1));
2002  return true;
2003  }
2004  return false;
2005 }
2006 
2007 
2008 // Method: SetEncodeAsPSF - currently used for ProRes compressed buffers
2009 // Input: NTV2Channel, NTV2K2FrameBufferQuality
2010 // Output: NONE
2011 bool CNTV2Card::SetEncodeAsPSF(NTV2Channel channel, NTV2EncodeAsPSF value)
2012 {
2013  if (IS_CHANNEL_INVALID (channel))
2014  return false;
2015  return WriteRegister (gChannelToControlRegNum [channel], value, kRegMaskEncodeAsPSF, kRegShiftEncodeAsPSF);
2016 }
2017 
2018 // Method: GetEncodeAsPSF - currently used for ProRes compressed buffers
2019 // Input: NTV2Channel
2020 // Output: NTV2K2FrameBufferQuality
2021 bool CNTV2Card::GetEncodeAsPSF (NTV2Channel inChannel, NTV2EncodeAsPSF & outValue)
2022 {
2023  if (IS_CHANNEL_INVALID (inChannel))
2024  return false;
2025  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskEncodeAsPSF, kRegShiftEncodeAsPSF);
2026 }
2027 
2028 // Method: SetFrameBufferOrientation
2029 // Input: NTV2Channel, NTV2VideoFrameBufferOrientation
2030 // Output: NONE
2031 bool CNTV2Card::SetFrameBufferOrientation (const NTV2Channel inChannel, const NTV2FBOrientation inValue)
2032 {
2033  if (IsMultiRasterWidgetChannel(inChannel))
2034  return inValue == NTV2_FRAMEBUFFER_ORIENTATION_NORMAL;
2035  if (IS_CHANNEL_INVALID(inChannel))
2036  return false;
2037  return WriteRegister (gChannelToControlRegNum[inChannel], inValue, kRegMaskFrameOrientation, kRegShiftFrameOrientation);
2038 }
2039 
2040 // Method: GetFrameBufferOrientation
2041 // Input: NTV2Channel
2042 // Output: NTV2VideoFrameBufferOrientation
2043 bool CNTV2Card::GetFrameBufferOrientation (const NTV2Channel inChannel, NTV2FBOrientation & outValue)
2044 {
2045  if (IsMultiRasterWidgetChannel(inChannel))
2046  {outValue = NTV2_FRAMEBUFFER_ORIENTATION_NORMAL; return true;}
2047  if (IS_CHANNEL_INVALID (inChannel))
2048  return false;
2049  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskFrameOrientation, kRegShiftFrameOrientation);
2050 }
2051 
2052 
2053 // Method: SetFrameBufferSize
2054 // Input: NTV2Channel, NTV2K2Framesize
2055 // Output: NONE
2056 bool CNTV2Card::SetFrameBufferSize (const NTV2Channel inChannel, const NTV2Framesize inValue)
2057 {
2058  if (IS_CHANNEL_INVALID(inChannel))
2059  return false;
2060 #if defined (NTV2_ALLOW_2MB_FRAMES)
2061  ULWord supports2m (0);
2062  ReadRegister(kRegGlobalControl2, &supports2m, kRegMask2MFrameSupport, kRegShift2MFrameSupport);
2063  if(supports2m == 1)
2064  {
2065  ULWord value2M (0);
2066  switch(inValue)
2067  {
2068  case NTV2_FRAMESIZE_2MB: value2M = 1; break;
2069  case NTV2_FRAMESIZE_4MB: value2M = 2; break;
2070  case NTV2_FRAMESIZE_6MB: value2M = 3; break;
2071  case NTV2_FRAMESIZE_8MB: value2M = 4; break;
2072  case NTV2_FRAMESIZE_10MB: value2M = 5; break;
2073  case NTV2_FRAMESIZE_12MB: value2M = 6; break;
2074  case NTV2_FRAMESIZE_14MB: value2M = 7; break;
2075  case NTV2_FRAMESIZE_16MB: value2M = 8; break;
2076  case NTV2_FRAMESIZE_18MB: value2M = 9; break;
2077  case NTV2_FRAMESIZE_20MB: value2M = 10; break;
2078  case NTV2_FRAMESIZE_22MB: value2M = 11; break;
2079  case NTV2_FRAMESIZE_24MB: value2M = 12; break;
2080  case NTV2_FRAMESIZE_26MB: value2M = 13; break;
2081  case NTV2_FRAMESIZE_28MB: value2M = 14; break;
2082  case NTV2_FRAMESIZE_30MB: value2M = 15; break;
2083  case NTV2_FRAMESIZE_32MB: value2M = 16; break;
2084  default: return false;
2085  }
2086  return WriteRegister(gChannelTo2MFrame [NTV2_CHANNEL1], value2M, kRegMask2MFrameSize, kRegShift2MFrameSupport);
2087  }
2088  else
2089 #endif // defined (NTV2_ALLOW_2MB_FRAMES)
2090  if (inValue == NTV2_FRAMESIZE_2MB || inValue == NTV2_FRAMESIZE_4MB || inValue == NTV2_FRAMESIZE_8MB || inValue == NTV2_FRAMESIZE_16MB)
2091  return WriteRegister (gChannelToControlRegNum [NTV2_CHANNEL1], inValue, kK2RegMaskFrameSize, kK2RegShiftFrameSize);
2092  return false;
2093 }
2094 
2095 // Method: GetK2FrameBufferSize
2096 // Input: NTV2Channel
2097 // Output: NTV2K2Framesize
2098 bool CNTV2Card::GetFrameBufferSize (const NTV2Channel inChannel, NTV2Framesize & outValue)
2099 {
2100  outValue = NTV2_FRAMESIZE_INVALID;
2101  if (!NTV2_IS_VALID_CHANNEL (inChannel))
2102  return false;
2103 #if defined (NTV2_ALLOW_2MB_FRAMES)
2104  ULWord supports2m (0);
2105  ReadRegister(kRegGlobalControl2, &supports2m, kRegMask2MFrameSupport, kRegShift2MFrameSupport);
2106  if(supports2m == 1)
2107  {
2108  ULWord frameSize (0);
2109  ReadRegister(gChannelTo2MFrame[inChannel], &frameSize, kRegMask2MFrameSize, kRegShift2MFrameSize);
2110  if (frameSize)
2111  {
2112  switch (frameSize)
2113  {
2114  case 1: outValue = NTV2_FRAMESIZE_2MB; break;
2115  case 2: outValue = NTV2_FRAMESIZE_4MB; break;
2116  case 3: outValue = NTV2_FRAMESIZE_6MB; break;
2117  case 4: outValue = NTV2_FRAMESIZE_8MB; break;
2118  case 5: outValue = NTV2_FRAMESIZE_10MB; break;
2119  case 6: outValue = NTV2_FRAMESIZE_12MB; break;
2120  case 7: outValue = NTV2_FRAMESIZE_14MB; break;
2121  case 8: outValue = NTV2_FRAMESIZE_16MB; break;
2122  case 9: outValue = NTV2_FRAMESIZE_18MB; break;
2123  case 10: outValue = NTV2_FRAMESIZE_20MB; break;
2124  case 11: outValue = NTV2_FRAMESIZE_22MB; break;
2125  case 12: outValue = NTV2_FRAMESIZE_24MB; break;
2126  case 13: outValue = NTV2_FRAMESIZE_26MB; break;
2127  case 14: outValue = NTV2_FRAMESIZE_28MB; break;
2128  case 15: outValue = NTV2_FRAMESIZE_30MB; break;
2129  case 16: outValue = NTV2_FRAMESIZE_32MB; break;
2130  default: return false;
2131  }
2132  NTV2_ASSERT (NTV2_IS_8MB_OR_16MB_FRAMESIZE(outValue));
2133  return true;
2134  }
2135  }
2136 #endif // defined (NTV2_ALLOW_2MB_FRAMES)
2137  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[NTV2_CHANNEL1], outValue, kK2RegMaskFrameSize, kK2RegShiftFrameSize);
2138 }
2139 
2140 
2141 bool CNTV2Card::DisableChannel (const NTV2Channel inChannel)
2142 {
2143  if (IsMultiRasterWidgetChannel(inChannel))
2144  return SetMultiRasterBypassEnable(false);
2145  return NTV2_IS_VALID_CHANNEL(inChannel)
2146  && WriteRegister (gChannelToControlRegNum [inChannel], ULWord (true), kRegMaskChannelDisable, kRegShiftChannelDisable);
2147 
2148 } // DisableChannel
2149 
2150 
2151 bool CNTV2Card::DisableChannels (const NTV2ChannelSet & inChannels)
2152 { UWord failures(0);
2153  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2154  if (!DisableChannel(*it))
2155  failures++;
2156  return !failures;
2157 
2158 } // DisableChannels
2159 
2160 
2161 bool CNTV2Card::EnableChannel (const NTV2Channel inChannel)
2162 {
2163  if (IsMultiRasterWidgetChannel(inChannel))
2164  return SetMultiRasterBypassEnable(true);
2165  return NTV2_IS_VALID_CHANNEL(inChannel)
2166  && WriteRegister (gChannelToControlRegNum[inChannel], ULWord(false), kRegMaskChannelDisable, kRegShiftChannelDisable);
2167 
2168 } // EnableChannel
2169 
2170 
2171 bool CNTV2Card::EnableChannels (const NTV2ChannelSet & inChannels, const bool inDisableOthers)
2172 { UWord failures(0);
2173  for (NTV2Channel chan(NTV2_CHANNEL1); chan < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); chan = NTV2Channel(chan+1))
2174  if (inChannels.find(chan) != inChannels.end())
2175  {
2176  if (!EnableChannel(chan))
2177  failures++;
2178  }
2179  else if (inDisableOthers)
2180  DisableChannel(chan);
2181  return !failures;
2182 
2183 } // EnableChannels
2184 
2185 
2186 bool CNTV2Card::IsChannelEnabled (const NTV2Channel inChannel, bool & outEnabled)
2187 {
2188  bool disabled (false);
2189  if (IsMultiRasterWidgetChannel(inChannel))
2190  return GetMultiRasterBypassEnable(outEnabled);
2191  if (IS_CHANNEL_INVALID(inChannel))
2192  return false;
2193  if (!CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], disabled, kRegMaskChannelDisable, kRegShiftChannelDisable))
2194  return false;
2195  outEnabled = disabled ? false : true;
2196  return true;
2197 } // IsChannelEnabled
2198 
2199 
2200 bool CNTV2Card::GetEnabledChannels (NTV2ChannelSet & outChannels)
2201 {
2202  UWord failures(0);
2203  bool enabled(false);
2204  outChannels.clear();
2205  for (NTV2Channel ch(NTV2_CHANNEL1); ch < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); ch = NTV2Channel(ch+1))
2206  if (!IsChannelEnabled (ch, enabled))
2207  failures++;
2208  else if (enabled)
2209  outChannels.insert(ch);
2210  return !failures;
2211 }
2212 
2213 
2214 bool CNTV2Card::GetDisabledChannels (NTV2ChannelSet & outChannels)
2215 {
2216  UWord failures(0);
2217  bool enabled(false);
2218  outChannels.clear();
2219  for (NTV2Channel ch(NTV2_CHANNEL1); ch < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); ch = NTV2Channel(ch+1))
2220  if (!IsChannelEnabled (ch, enabled))
2221  failures++;
2222  else if (!enabled)
2223  outChannels.insert(ch);
2224  return !failures;
2225 }
2226 
2227 #if !defined(NTV2_DEPRECATE_16_2)
2228  bool CNTV2Card::SetPCIAccessFrame (const NTV2Channel inChannel, const ULWord inValue, const bool inWaitForVBI)
2229  {
2230  if (IS_CHANNEL_INVALID(inChannel))
2231  return false;
2232  const bool result (WriteRegister (gChannelToPCIAccessFrameRegNum[inChannel], inValue));
2233  if (inWaitForVBI)
2234  WaitForOutputVerticalInterrupt (inChannel);
2235  return result;
2236  }
2237 
2238  bool CNTV2Card::GetPCIAccessFrame (const NTV2Channel inChannel, ULWord & outValue)
2239  {
2240  return !IS_CHANNEL_INVALID(inChannel)
2241  && ReadRegister (gChannelToPCIAccessFrameRegNum[inChannel], outValue);
2242  }
2243 
2244  bool CNTV2Card::FlipFlopPage (const NTV2Channel inCh)
2245  {
2246  ULWord nextFrm(0), outFrm(0);
2247  return !IS_CHANNEL_INVALID(inCh)
2248  && ReadRegister(gChannelToPCIAccessFrameRegNum[inCh], nextFrm) // GetPCIAccessFrame(inCh, nextFrm)
2249  && GetOutputFrame(inCh, outFrm)
2250  && SetOutputFrame(inCh, nextFrm)
2251  && WriteRegister(gChannelToPCIAccessFrameRegNum[inCh], outFrm) && WaitForOutputVerticalInterrupt(inCh); // SetPCIAccessFrame(inCh, outFrm);
2252  }
2253 #endif // !defined (NTV2_DEPRECATE_16_2)
2254 
2255 bool CNTV2Card::SetOutputFrame (const NTV2Channel inChannel, const ULWord value)
2256 {
2257  if (IsMultiRasterWidgetChannel(inChannel))
2258  return false;
2259  if (IS_CHANNEL_INVALID(inChannel))
2260  return false;
2261  return WriteRegister (gChannelToOutputFrameRegNum [inChannel], value);
2262 }
2263 
2264 bool CNTV2Card::GetOutputFrame (const NTV2Channel inChannel, ULWord & outValue)
2265 {
2266  if (IsMultiRasterWidgetChannel(inChannel))
2267  {outValue = 0; return false;}
2268  if (IS_CHANNEL_INVALID(inChannel))
2269  return false;
2270  return ReadRegister (gChannelToOutputFrameRegNum [inChannel], outValue);
2271 }
2272 
2273 bool CNTV2Card::SetInputFrame (const NTV2Channel inChannel, const ULWord value)
2274 {
2275  if (IsMultiRasterWidgetChannel(inChannel))
2276  return WriteRegister(kRegMROutControl, value, kRegMaskMRFrameLocation, kRegShiftMRFrameLocation);
2277  if (IS_CHANNEL_INVALID(inChannel))
2278  return false;
2279  return WriteRegister (gChannelToInputFrameRegNum [inChannel], value);
2280 }
2281 
2282 bool CNTV2Card::GetInputFrame (const NTV2Channel inChannel, ULWord & outValue)
2283 {
2284  if (IsMultiRasterWidgetChannel(inChannel))
2285  return ReadRegister(kRegMROutControl, outValue, kRegMaskMRFrameLocation, kRegShiftMRFrameLocation);
2286  if (IS_CHANNEL_INVALID(inChannel))
2287  return false;
2288  return ReadRegister (gChannelToInputFrameRegNum[inChannel], outValue);
2289 }
2290 
2291 bool CNTV2Card::SetAlphaFromInput2Bit (ULWord value) {return WriteRegister (kRegCh1Control, value, kRegMaskAlphaFromInput2, kRegShiftAlphaFromInput2);}
2292 bool CNTV2Card::GetAlphaFromInput2Bit (ULWord & outValue) {return ReadRegister (kRegCh1Control, outValue, kRegMaskAlphaFromInput2, kRegShiftAlphaFromInput2);}
2293 
2294 bool CNTV2Card::ReadLineCount (ULWord & outValue)
2295 {
2296  return ReadRegister (kRegLineCount, outValue);
2297 }
2298 
2299 bool CNTV2Card::ReadFlashProgramControl (ULWord & outValue)
2300 {
2301  return ReadRegister (kRegFlashProgramReg, outValue);
2302 }
2303 
2304 
2305 // Determine if Xilinx programmed
2306 // Input: NONE
2307 // Output: ULWord or equivalent(i.e. ULWord).
2308 bool CNTV2Card::IsXilinxProgrammed()
2309 {
2310  ULWord programFlashValue;
2311  if(ReadFlashProgramControl(programFlashValue))
2312  {
2313  if ((programFlashValue & BIT(9)) == BIT(9))
2314  {
2315  return true;
2316  }
2317  }
2318  return false;
2319 }
2320 
2321 bool CNTV2Card::GetProgramStatus(SSC_GET_FIRMWARE_PROGRESS_STRUCT *statusStruct)
2322 {
2323  ULWord totalSize = 0;
2324  ULWord totalProgress = 0;
2325  ULWord state = kProgramStateFinished;
2326  ReadRegister(kVRegFlashSize, totalSize);
2327  ReadRegister(kVRegFlashStatus, totalProgress);
2328  ReadRegister(kVRegFlashState, state);
2329  statusStruct->programTotalSize = totalSize;
2330  statusStruct->programProgress = totalProgress;
2331  statusStruct->programState = ProgramState(state);
2332  return true;
2333 }
2334 
2335 bool CNTV2Card::ProgramMainFlash (const string & inFileName, const bool bInForceUpdate, const bool bInQuiet)
2336 {
2337  CNTV2KonaFlashProgram devFlasher(GetIndexNumber());
2338  if (bInQuiet)
2339  devFlasher.SetQuietMode();
2340  ostringstream msgs;
2341  string progResults;
2342  const bool ok(devFlasher.SetBitFile(inFileName, msgs, MAIN_FLASHBLOCK));
2343  if (bInForceUpdate)
2344  devFlasher.SetMBReset();
2345  if (ok)
2346  progResults = devFlasher.Program(false);
2347  else
2348  {AJA_sERROR(AJA_DebugUnit_UserGeneric, INSTP(this) << "::" << AJAFUNC << ": " << msgs.str()); return false;}
2349  if (!progResults.empty())
2350  AJA_sERROR(AJA_DebugUnit_UserGeneric, INSTP(this) << "::" << AJAFUNC << ": " << progResults);
2351  return progResults.empty();
2352 }
2353 
2354 bool CNTV2Card::GetRunningFirmwarePackageRevision (ULWord & outRevision)
2355 {
2356  outRevision = 0;
2357  if (!IsOpen())
2358  return false; // Not open
2359  if (!IsIPDevice())
2360  return false; // No MicroBlaze
2361  return ReadRegister(kRegSarekPackageVersion + SAREK_REGS, outRevision);
2362 }
2363 
2364 bool CNTV2Card::GetRunningFirmwareRevision (UWord & outRevision)
2365 {
2366  outRevision = 0;
2367  if (!IsOpen())
2368  return false;
2369 
2370  uint32_t regValue (0);
2371  if (!ReadRegister (kRegDMAControl, regValue))
2372  return false;
2373 
2374  outRevision = uint16_t((regValue & 0x0000FF00) >> 8);
2375  return true;
2376 }
2377 
2378 bool CNTV2Card::GetRunningFirmwareDate (UWord & outYear, UWord & outMonth, UWord & outDay)
2379 {
2380  outYear = outMonth = outDay = 0;
2381  if (!IsSupported(kDeviceCanReportRunningFirmwareDate))
2382  return false;
2383 
2384  uint32_t regValue (0);
2385  if (!ReadRegister(kRegBitfileDate, regValue))
2386  return false;
2387 
2388  const UWord yearBCD ((regValue & 0xFFFF0000) >> 16); // Year number in BCD
2389  const UWord monthBCD ((regValue & 0x0000FF00) >> 8); // Month number in BCD
2390  const UWord dayBCD (regValue & 0x000000FF); // Day number in BCD
2391 
2392  outYear = ((yearBCD & 0xF000) >> 12) * 1000
2393  + ((yearBCD & 0x0F00) >> 8) * 100
2394  + ((yearBCD & 0x00F0) >> 4) * 10
2395  + (yearBCD & 0x000F);
2396 
2397  outMonth = ((monthBCD & 0x00F0) >> 4) * 10 + (monthBCD & 0x000F);
2398 
2399  outDay = ((dayBCD & 0x00F0) >> 4) * 10 + (dayBCD & 0x000F);
2400 
2401  return outYear > 2010
2402  && outMonth > 0 && outMonth < 13
2403  && outDay > 0 && outDay < 32; // If the date's valid, then it's supported; otherwise, it ain't
2404 }
2405 
2406 
2407 bool CNTV2Card::GetRunningFirmwareTime (UWord & outHours, UWord & outMinutes, UWord & outSeconds)
2408 {
2409  outHours = outMinutes = outSeconds = 0;
2410  if (!IsSupported(kDeviceCanReportRunningFirmwareDate))
2411  return false;
2412 
2413  uint32_t regValue (0);
2414  if (!ReadRegister(kRegBitfileTime, regValue))
2415  return false;
2416 
2417  const UWord hoursBCD ((regValue & 0x00FF0000) >> 16); // Hours number in BCD
2418  const UWord minutesBCD ((regValue & 0x0000FF00) >> 8); // Minutes number in BCD
2419  const UWord secondsBCD (regValue & 0x000000FF); // Seconds number in BCD
2420 
2421  outHours = ((hoursBCD & 0x00F0) >> 4) * 10 + (hoursBCD & 0x000F);
2422 
2423  outMinutes = ((minutesBCD & 0x00F0) >> 4) * 10 + (minutesBCD & 0x000F);
2424 
2425  outSeconds = ((secondsBCD & 0x00F0) >> 4) * 10 + (secondsBCD & 0x000F);
2426 
2427  return outHours < 24 && outMinutes < 60 && outSeconds < 60; // If the time's valid, then it's supported; otherwise, it ain't
2428 }
2429 
2430 
2431 bool CNTV2Card::GetRunningFirmwareDate (std::string & outDate, std::string & outTime)
2432 {
2433  outDate = outTime = string();
2434  UWord yr(0), mo(0), dy(0), hr(0), mn(0), sec(0);
2435  if (!GetRunningFirmwareDate (yr, mo, dy))
2436  return false;
2437  if (!GetRunningFirmwareTime (hr, mn, sec))
2438  return false;
2439 
2440  ostringstream date, time;
2441  date << DEC0N(yr,4) << "/" << DEC0N(mo,2) << "/" << DEC0N(dy,2);
2442  time << DEC0N(hr,2) << ":" << DEC0N(mn,2) << ":" << DEC0N(sec,2);
2443 
2444  outDate = date.str();
2445  outTime = time.str();
2446  return true;
2447 }
2448 
2449 
2450 bool CNTV2Card::GetRunningFirmwareUserID (ULWord & outUserID)
2451 {
2452  outUserID = 0;
2453  if (!IsOpen())
2454  return false;
2455 
2456  ULWord regValue (0);
2457  if (!ReadRegister (kRegFirmwareUserID, regValue))
2458  return false;
2459 
2460  outUserID = regValue;
2461  return true;
2462 }
2463 
2464 
2466 
2467 bool CNTV2Card::GetPCIDeviceID (ULWord & outPCIDeviceID) {return ReadRegister (kVRegPCIDeviceID, outPCIDeviceID);}
2468 
2469 bool CNTV2Card::SupportsP2PTransfer (void)
2470 {
2471  ULWord pciID (0);
2472 
2473  if (GetPCIDeviceID (pciID))
2474  switch (pciID)
2475  {
2476  case 0xDB07: // Kona3G + P2P
2477  case 0xDB08: // Kona3G Quad + P2P
2478  case 0xEB0B: // Kona4quad
2479  case 0xEB0C: // Kona4ufc
2480  case 0xEB0E: // Corvid 44
2481  case 0xEB0D: // Corvid 88
2482  return true;
2483 
2484  default:
2485  return false;
2486  }
2487  return false;
2488 }
2489 
2490 
2491 bool CNTV2Card::SupportsP2PTarget (void)
2492 {
2493  ULWord pciID (0);
2494 
2495  if (GetPCIDeviceID (pciID))
2496  switch (pciID)
2497  {
2498  case 0xDB07: // Kona3G + P2P
2499  case 0xDB08: // Kona3G Quad + P2P
2500  case 0xEB0C: // Kona4ufc
2501  case 0xEB0E: // Corvid 44
2502  case 0xEB0D: // Corvid 88
2503  return true;
2504 
2505  default:
2506  return false;
2507  }
2508  return false;
2509 }
2510 
2511 
2512 bool CNTV2Card::SetRegisterWriteMode (const NTV2RegisterWriteMode value, const NTV2Channel inFrameStore)
2513 {
2514  bool ret;
2515 
2516  if (IS_CHANNEL_INVALID(inFrameStore))
2517  return false;
2518  if (IsMultiFormatActive())
2519  return WriteRegister (gChannelToGlobalControlRegNum[inFrameStore], value, kRegMaskRegClocking, kRegShiftRegClocking);
2520  if (IsSupported(kDeviceCanDoMultiFormat))
2521  {
2522  for (NTV2Channel chan(NTV2_CHANNEL1); chan < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); chan = NTV2Channel(chan+1))
2523  {
2524  ret = WriteRegister (gChannelToGlobalControlRegNum[chan], value, kRegMaskRegClocking, kRegShiftRegClocking);
2525  if (!ret)
2526  return false;
2527  }
2528  return true;
2529  }
2530  return WriteRegister (gChannelToGlobalControlRegNum[NTV2_CHANNEL1], value, kRegMaskRegClocking, kRegShiftRegClocking);
2531 }
2532 
2533 
2534 bool CNTV2Card::GetRegisterWriteMode (NTV2RegisterWriteMode & outValue, const NTV2Channel inFrameStore)
2535 {
2536  if (IS_CHANNEL_INVALID (inFrameStore))
2537  return false;
2538  ULWord value(0);
2539  if (!ReadRegister(gChannelToGlobalControlRegNum[IsMultiFormatActive() ? inFrameStore : NTV2_CHANNEL1],
2540  value, kRegMaskRegClocking, kRegShiftRegClocking))
2541  return false;
2542  outValue = NTV2RegisterWriteMode(value);
2543  return true;
2544 }
2545 
2546 
2547 bool CNTV2Card::SetLEDState (ULWord value) {return WriteRegister (kRegGlobalControl, value, kRegMaskLED, kRegShiftLED);}
2548 bool CNTV2Card::GetLEDState (ULWord & outValue) {return ReadRegister (kRegGlobalControl, outValue, kRegMaskLED, kRegShiftLED);}
2549 
2550 
2552 // RP188 methods
2554 
2555 bool CNTV2Card::SetRP188Mode (const NTV2Channel inChannel, const NTV2_RP188Mode inValue)
2556 {
2557  if (IS_CHANNEL_INVALID (inChannel))
2558  return false;
2559  return WriteRegister (gChannelToRP188ModeGCRegisterNum [inChannel], inValue, gChannelToRP188ModeMasks [inChannel], gChannelToRP188ModeShifts [inChannel]);
2560 }
2561 
2562 
2563 bool CNTV2Card::GetRP188Mode (const NTV2Channel inChannel, NTV2_RP188Mode & outMode)
2564 {
2565  if (IS_CHANNEL_INVALID (inChannel))
2566  return false;
2567  const bool result (CNTV2DriverInterface::ReadRegister (gChannelToRP188ModeGCRegisterNum[inChannel], outMode, gChannelToRP188ModeMasks[inChannel], gChannelToRP188ModeShifts[inChannel]));
2568  if (!result)
2569  outMode = NTV2_RP188_INVALID;
2570  return result;
2571 }
2572 
2573 
2574 bool CNTV2Card::GetRP188Data (const NTV2Channel inChannel, NTV2_RP188 & outRP188Data)
2575 {
2576  outRP188Data = NTV2_RP188();
2577  if (IS_CHANNEL_INVALID (inChannel))
2578  return false;
2579  return ReadRegister (gChlToRP188DBBRegNum[inChannel], outRP188Data.fDBB, kRegMaskRP188DBB, kRegShiftRP188DBB)
2580  && ReadRegister (gChlToRP188Bits031RegNum[inChannel], outRP188Data.fLo)
2581  && ReadRegister (gChlToRP188Bits3263RegNum[inChannel], outRP188Data.fHi);
2582 }
2583 
2584 
2585 bool CNTV2Card::SetRP188Data (const NTV2Channel inChannel, const NTV2_RP188 & inRP188Data)
2586 {
2587  if (IS_CHANNEL_INVALID (inChannel))
2588  return false;
2589  if (!inRP188Data.IsValid())
2590  return false;
2591  return WriteRegister (gChlToRP188DBBRegNum[inChannel], inRP188Data.fDBB, kRegMaskRP188DBB, kRegShiftRP188DBB)
2592  && WriteRegister (gChlToRP188Bits031RegNum[inChannel], inRP188Data.fLo)
2593  && WriteRegister (gChlToRP188Bits3263RegNum[inChannel], inRP188Data.fHi);
2594 }
2595 
2596 
2597 bool CNTV2Card::SetRP188SourceFilter (const NTV2Channel inChannel, UWord inValue)
2598 {
2599  if (IS_CHANNEL_INVALID (inChannel))
2600  return false;
2601  return WriteRegister (gChlToRP188DBBRegNum[inChannel], ULWord(inValue), kRegMaskRP188SourceSelect, kRegShiftRP188Source);
2602 }
2603 
2604 
2605 bool CNTV2Card::GetRP188SourceFilter (const NTV2Channel inChannel, UWord & outValue)
2606 {
2607  if (IS_CHANNEL_INVALID (inChannel))
2608  return false;
2609  return CNTV2DriverInterface::ReadRegister (gChlToRP188DBBRegNum[inChannel], outValue, kRegMaskRP188SourceSelect, kRegShiftRP188Source);
2610 }
2611 
2612 
2613 bool CNTV2Card::IsRP188BypassEnabled (const NTV2Channel inChannel, bool & outIsBypassEnabled)
2614 {
2615  if (IS_CHANNEL_INVALID (inChannel))
2616  return false;
2617  // Bit 23 of the RP188 DBB register will be set if output timecode will be grabbed directly from an input (bypass source)...
2618  ULWord regValue (0);
2619  bool result (NTV2_IS_VALID_CHANNEL(inChannel) && ReadRegister(gChlToRP188DBBRegNum[inChannel], regValue));
2620  if (result)
2621  outIsBypassEnabled = regValue & BIT(23);
2622  return result;
2623 }
2624 
2625 
2626 bool CNTV2Card::DisableRP188Bypass (const NTV2Channel inChannel)
2627 {
2628  if (IS_CHANNEL_INVALID (inChannel))
2629  return false;
2630  // Clear bit 23 of my output destination's RP188 DBB register...
2631  return NTV2_IS_VALID_CHANNEL (inChannel) && WriteRegister (gChlToRP188DBBRegNum[inChannel], 0, BIT(23), 23);
2632 }
2633 
2634 
2635 bool CNTV2Card::EnableRP188Bypass (const NTV2Channel inChannel)
2636 {
2637  if (IS_CHANNEL_INVALID (inChannel))
2638  return false;
2639  // Set bit 23 of my output destination's RP188 DBB register...
2640  return NTV2_IS_VALID_CHANNEL (inChannel) && WriteRegister (gChlToRP188DBBRegNum [inChannel], 1, BIT(23), 23);
2641 }
2642 
2643 static const ULWord gSDIOutToRP188Input[] = { 0, 2, 1, 3, 0, 2, 1, 3, 0 };
2644 
2645 bool CNTV2Card::SetRP188BypassSource (const NTV2Channel inSDIOutput, const UWord inSDIInput)
2646 {
2647  if (IS_CHANNEL_INVALID(inSDIOutput))
2648  return false;
2649  if (IS_CHANNEL_INVALID(NTV2Channel(inSDIInput)))
2650  return false;
2651  return WriteRegister(gChlToRP188DBBRegNum[inSDIOutput], gSDIOutToRP188Input[inSDIInput], BIT(21)|BIT(22), 21);
2652 }
2653 
2654 bool CNTV2Card::GetRP188BypassSource (const NTV2Channel inSDIOutput, UWord & outSDIInput)
2655 {
2656  if (IS_CHANNEL_INVALID(inSDIOutput))
2657  return false;
2658  ULWord val(0);
2659  if (!ReadRegister(gChlToRP188DBBRegNum[inSDIOutput], val, BIT(21)|BIT(22), 21))
2660  return false;
2661  switch(val)
2662  {
2663  case 0: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 0 : 4; break;
2664  case 2: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 1 : 5; break;
2665  case 1: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 2 : 6; break;
2666  case 3: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 3 : 7; break;
2667  default: return false;
2668  }
2669  return true;
2670 }
2671 
2672 
2673 bool CNTV2Card::SetVideoLimiting (const NTV2VideoLimiting inValue)
2674 {
2675  if (!NTV2_IS_VALID_VIDEOLIMITING(inValue))
2676  return false;
2677  CVIDINFO("'" << GetDisplayName() << "' set to " << ::NTV2VideoLimitingToString(inValue));
2678  return WriteRegister (kRegVidProc1Control, inValue, kRegMaskVidProcLimiting, kRegShiftVidProcLimiting);
2679 }
2680 
2681 bool CNTV2Card::GetVideoLimiting (NTV2VideoLimiting & outValue)
2682 {
2683  return CNTV2DriverInterface::ReadRegister (kRegVidProc1Control, outValue, kRegMaskVidProcLimiting, kRegShiftVidProcLimiting);
2684 }
2685 
2686 
2687 //SetEnableVANCData
2688 // Call SetVideoFormat with the desired video format BEFORE you call this function!
2689 bool CNTV2Card::SetEnableVANCData (const bool inVANCenable, const bool inTallerVANC, const NTV2Channel inChannel)
2690 {
2691  return SetVANCMode (NTV2VANCModeFromBools(inVANCenable, inTallerVANC), IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2692 }
2693 
2694 bool CNTV2Card::SetVANCMode (const NTV2ChannelSet & inChannels, const NTV2VANCMode inVancMode)
2695 {
2696  size_t errors(0);
2697  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2698  if (!SetVANCMode (inVancMode, *it))
2699  errors++;
2700  return !errors;
2701 }
2702 
2703 
2704 bool CNTV2Card::SetVANCMode (const NTV2VANCMode inVancMode, const NTV2Channel inChannel)
2705 {
2706  const NTV2Channel ch (IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2707  if (IsMultiRasterWidgetChannel(ch))
2708  return inVancMode == NTV2_VANCMODE_OFF;
2709  if (IS_CHANNEL_INVALID(ch))
2710  return false;
2711  if (!NTV2_IS_VALID_VANCMODE(inVancMode))
2712  return false;
2713 
2714  NTV2FrameGeometry fg(NTV2_FG_INVALID);
2715  NTV2Standard st(NTV2_STANDARD_INVALID);
2716  GetStandard(st, ch);
2717  GetFrameGeometry(fg, ch);
2718  switch (st)
2719  {
2720  case NTV2_STANDARD_1080:
2721  case NTV2_STANDARD_1080p:
2722  if (fg == NTV2_FG_1920x1112 || fg == NTV2_FG_1920x1114 || fg == NTV2_FG_1920x1080)
2723  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_1920x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_1920x1112 : NTV2_FG_1920x1080);
2724  else if (NTV2_IS_QUAD_FRAME_GEOMETRY(fg)) // 4K
2725  ; // do nothing for now
2726  else if (NTV2_IS_2K_1080_FRAME_GEOMETRY(fg)) // 2Kx1080
2727  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_2048x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_2048x1112 : NTV2_FG_2048x1080);
2728  break;
2729 
2730  case NTV2_STANDARD_720:
2731  fg = NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_FG_1280x740 : NTV2_FG_1280x720;
2732  if (NTV2_IS_VANCMODE_TALLER(inVancMode))
2733  CVIDWARN("'taller' mode requested for 720p -- using 'tall' geometry instead");
2734  break;
2735 
2736  case NTV2_STANDARD_525:
2737  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_720x514 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_720x508 : NTV2_FG_720x486);
2738  break;
2739 
2740  case NTV2_STANDARD_625:
2741  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_720x612 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_720x598 : NTV2_FG_720x576);
2742  break;
2743 
2744  case NTV2_STANDARD_2K:
2745  fg = NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_FG_2048x1588 : NTV2_FG_2048x1556;
2746  if (NTV2_IS_VANCMODE_TALLER(inVancMode))
2747  CVIDWARN("'taller' mode requested for 2K standard '" << ::NTV2StandardToString(st) << "' -- using 'tall' instead");
2748  break;
2749 
2750  case NTV2_STANDARD_2Kx1080p:
2751  case NTV2_STANDARD_2Kx1080i:
2752  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_2048x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_2048x1112 : NTV2_FG_2048x1080);
2753  break;
2754 
2755  case NTV2_STANDARD_3840x2160p:
2756  case NTV2_STANDARD_4096x2160p:
2757  case NTV2_STANDARD_3840HFR:
2758  case NTV2_STANDARD_4096HFR:
2759  case NTV2_STANDARD_7680:
2760  case NTV2_STANDARD_8192:
2761  case NTV2_STANDARD_3840i:
2762  case NTV2_STANDARD_4096i:
2763  if (NTV2_IS_VANCMODE_ON(inVancMode))
2764  CVIDWARN("'tall' or 'taller' mode requested for '" << ::NTV2StandardToString(st) << "' -- using non-VANC geometry instead");
2765  break;
2766  #if defined(_DEBUG)
2767  case NTV2_STANDARD_INVALID: return false;
2768  #else
2769  default: return false;
2770  #endif // _DEBUG
2771  }
2772  SetFrameGeometry (fg, false/*ajaRetail*/, ch);
2773  CVIDINFO("'" << GetDisplayName() << "' Ch" << DEC(ch+1) << ": set to " << ::NTV2VANCModeToString(inVancMode) << " for " << ::NTV2StandardToString(st) << " and " << ::NTV2FrameGeometryToString(fg));
2774 
2775  // Only muck with limiting if not the xena2k board. Xena2k only turns off limiting in VANC area. Active video uses vidproccontrol setting...
2776  if (!::NTV2DeviceNeedsRoutingSetup(GetDeviceID()))
2777  SetVideoLimiting (NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_VIDEOLIMITING_OFF : NTV2_VIDEOLIMITING_LEGALSDI);
2778 
2779  return true;
2780 }
2781 
2782 
2783 //SetEnableVANCData - extended params
2784 bool CNTV2Card::SetEnableVANCData (const bool inVANCenabled, const bool inTallerVANC, const NTV2Standard inStandard, const NTV2FrameGeometry inFrameGeometry, const NTV2Channel inChannel)
2785 { (void) inStandard; (void) inFrameGeometry;
2786  if (inTallerVANC && !inVANCenabled)
2787  return false; // conflicting VANC params
2788  return SetVANCMode (NTV2VANCModeFromBools (inVANCenabled, inTallerVANC), inChannel);
2789 }
2790 
2791 
2792 bool CNTV2Card::GetVANCMode (NTV2VANCMode & outVancMode, const NTV2Channel inChannel)
2793 {
2794  bool isTall (false);
2795  bool isTaller (false);
2796  const NTV2Channel channel (IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2797  NTV2Standard standard (NTV2_STANDARD_INVALID);
2798  NTV2FrameGeometry frameGeometry (NTV2_FG_INVALID);
2799 
2800  if (IsMultiRasterWidgetChannel(channel))
2801  {outVancMode = NTV2_VANCMODE_OFF; return true;}
2802 
2803  outVancMode = NTV2_VANCMODE_INVALID;
2804  if (IS_CHANNEL_INVALID (channel))
2805  return false;
2806 
2807  GetStandard (standard, channel);
2808  GetFrameGeometry (frameGeometry, channel);
2809 
2810  switch (standard)
2811  {
2812  case NTV2_STANDARD_1080:
2813  case NTV2_STANDARD_1080p:
2814  case NTV2_STANDARD_2Kx1080p: // ** MrBill ** IS THIS CORRECT?
2815  case NTV2_STANDARD_2Kx1080i: // ** MrBill ** IS THIS CORRECT?
2816  if ( frameGeometry == NTV2_FG_1920x1112 || frameGeometry == NTV2_FG_2048x1112 ||
2817  frameGeometry == NTV2_FG_1920x1114 || frameGeometry == NTV2_FG_2048x1114)
2818  isTall = true;
2819  if ( frameGeometry == NTV2_FG_1920x1114 || frameGeometry == NTV2_FG_2048x1114)
2820  isTaller = true;
2821  break;
2822  case NTV2_STANDARD_720:
2823  if ( frameGeometry == NTV2_FG_1280x740)
2824  isTall = true;
2825  break;
2826  case NTV2_STANDARD_525:
2827  if ( frameGeometry == NTV2_FG_720x508 ||
2828  frameGeometry == NTV2_FG_720x514)
2829  isTall = true;
2830  if ( frameGeometry == NTV2_FG_720x514 )
2831  isTaller = true;
2832  break;
2833  case NTV2_STANDARD_625:
2834  if ( frameGeometry == NTV2_FG_720x598 ||
2835  frameGeometry == NTV2_FG_720x612)
2836  isTall = true;
2837  if ( frameGeometry == NTV2_FG_720x612 )
2838  isTaller = true;
2839  break;
2840  case NTV2_STANDARD_2K:
2841  if ( frameGeometry == NTV2_FG_2048x1588)
2842  isTall = true;
2843  break;
2844  case NTV2_STANDARD_3840x2160p:
2845  case NTV2_STANDARD_4096x2160p:
2846  case NTV2_STANDARD_3840HFR:
2847  case NTV2_STANDARD_4096HFR:
2848  case NTV2_STANDARD_7680:
2849  case NTV2_STANDARD_8192:
2850  case NTV2_STANDARD_3840i:
2851  case NTV2_STANDARD_4096i:
2852  break;
2853  #if defined (_DEBUG)
2854  case NTV2_NUM_STANDARDS: return false;
2855  #else
2856  default: return false;
2857  #endif
2858  }
2859  outVancMode = NTV2VANCModeFromBools (isTall, isTaller);
2860  return true;
2861 }
2862 
2863 
2864 bool CNTV2Card::SetVANCShiftMode (NTV2Channel inChannel, NTV2VANCDataShiftMode inValue)
2865 {
2866  if (IsMultiRasterWidgetChannel(inChannel))
2867  return inValue == NTV2_VANCDATA_NORMAL;
2868  if (IS_CHANNEL_INVALID (inChannel))
2869  return false;
2870  CVIDINFO("'" << GetDisplayName() << "' Ch" << DEC(inChannel+1) << ": Vanc data shift " << (inValue ? "enabled" : "disabled"));
2871  return WriteRegister (gChannelToControlRegNum [inChannel], inValue, kRegMaskVidProcVANCShift, kRegShiftVidProcVANCShift);
2872 }
2873 
2874 
2875 bool CNTV2Card::SetVANCShiftMode (NTV2ChannelSet & inChannels, const NTV2VANCDataShiftMode inMode)
2876 {
2877  size_t errors(0);
2878  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2879  if (!SetVANCShiftMode(*it, inMode))
2880  errors++;
2881  return !errors;
2882 }
2883 
2884 
2885 bool CNTV2Card::GetVANCShiftMode (NTV2Channel inChannel, NTV2VANCDataShiftMode & outValue)
2886 {
2887  if (IsMultiRasterWidgetChannel(inChannel))
2888  {outValue = NTV2_VANCDATA_NORMAL; return true;}
2889  if (IS_CHANNEL_INVALID (inChannel))
2890  return false;
2891  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskVidProcVANCShift, kRegShiftVidProcVANCShift);
2892 }
2893 
2894 
2895 bool CNTV2Card::SetPulldownMode (NTV2Channel inChannel, bool inValue)
2896 {
2897  if (IS_CHANNEL_INVALID (inChannel))
2898  return false;
2899  return WriteRegister (inChannel == NTV2_CHANNEL2 ? kRegCh2ControlExtended : kRegCh1ControlExtended, inValue, kK2RegMaskPulldownMode, kK2RegShiftPulldownMode);
2900 }
2901 
2902 
2903 bool CNTV2Card::GetPulldownMode (NTV2Channel inChannel, bool & outValue)
2904 {
2905  ULWord value(0);
2906  if (IS_CHANNEL_INVALID (inChannel))
2907  return false;
2908  if (ReadRegister (inChannel == NTV2_CHANNEL2 ? kRegCh2ControlExtended : kRegCh1ControlExtended, value, kK2RegMaskPulldownMode, kK2RegShiftPulldownMode))
2909  {
2910  outValue = value ? true : false;
2911  return true;
2912  }
2913  return false;
2914 }
2915 
2916 
2917 bool CNTV2Card::SetMixerVancOutputFromForeground (const UWord inWhichMixer, const bool inFromForegroundSource)
2918 {
2919  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2920  return false;
2921  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": Vanc from " << (inFromForegroundSource ? "FG" : "BG"));
2922  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inFromForegroundSource ? 1 : 0, kRegMaskVidProcVancSource, kRegShiftVidProcVancSource);
2923 }
2924 
2925 
2926 bool CNTV2Card::GetMixerVancOutputFromForeground (const UWord inWhichMixer, bool & outIsFromForegroundSource)
2927 {
2928  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2929  return false;
2930 
2931  ULWord value (0);
2932  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kRegMaskVidProcVancSource, kRegShiftVidProcVancSource));
2933  if (result)
2934  outIsFromForegroundSource = value ? true : false;
2935  return result;
2936 }
2937 
2938 bool CNTV2Card::SetMixerFGInputControl (const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
2939 {
2940  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2941  return false;
2942  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": FG input ctrl=" << ::NTV2MixerInputControlToString(inInputControl));
2943  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inInputControl, kK2RegMaskXena2FgVidProcInputControl, kK2RegShiftXena2FgVidProcInputControl);
2944 }
2945 
2946 
2947 bool CNTV2Card::GetMixerFGInputControl (const UWord inWhichMixer, NTV2MixerKeyerInputControl & outInputControl)
2948 {
2949  outInputControl = NTV2MIXERINPUTCONTROL_INVALID;
2950  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2951  return false;
2952 
2953  ULWord value (0);
2954  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2FgVidProcInputControl, kK2RegShiftXena2FgVidProcInputControl));
2955  if (result)
2956  outInputControl = static_cast <NTV2MixerKeyerInputControl> (value);
2957  return result;
2958 }
2959 
2960 
2961 bool CNTV2Card::SetMixerBGInputControl (const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
2962 {
2963  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2964  return false;
2965  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": BG input ctrl=" << ::NTV2MixerInputControlToString(inInputControl));
2966  return WriteRegister (gIndexToVidProcControlRegNum [inWhichMixer], inInputControl, kK2RegMaskXena2BgVidProcInputControl, kK2RegShiftXena2BgVidProcInputControl);
2967 }
2968 
2969 
2970 bool CNTV2Card::GetMixerBGInputControl (const UWord inWhichMixer, NTV2MixerKeyerInputControl & outInputControl)
2971 {
2972  outInputControl = NTV2MIXERINPUTCONTROL_INVALID;
2973  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2974  return false;
2975 
2976  ULWord value (0);
2977  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2BgVidProcInputControl, kK2RegShiftXena2BgVidProcInputControl));
2978  if (result)
2979  outInputControl = static_cast <NTV2MixerKeyerInputControl> (value);
2980  return result;
2981 }
2982 
2983 
2984 bool CNTV2Card::SetMixerMode (const UWord inWhichMixer, const NTV2MixerKeyerMode inMode)
2985 {
2986  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2987  return false;
2988  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": mode=" << ::NTV2MixerKeyerModeToString(inMode));
2989  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inMode, kK2RegMaskXena2VidProcMode, kK2RegShiftXena2VidProcMode);
2990 }
2991 
2992 
2993 bool CNTV2Card::GetMixerMode (const UWord inWhichMixer, NTV2MixerKeyerMode & outMode)
2994 {
2995  outMode = NTV2MIXERMODE_INVALID;
2996 
2997  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2998  return false;
2999 
3000  ULWord value (0);
3001  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2VidProcMode, kK2RegShiftXena2VidProcMode));
3002  if (result)
3003  outMode = static_cast <NTV2MixerKeyerMode> (value);
3004  return result;
3005 }
3006 
3007 
3008 bool CNTV2Card::SetMixerCoefficient (const UWord inWhichMixer, const ULWord inMixCoefficient)
3009 {
3010  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3011  return false;
3012  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": mixCoeff=" << xHEX0N(inMixCoefficient,8));
3013  return WriteRegister (gIndexToVidProcMixCoeffRegNum[inWhichMixer], inMixCoefficient);
3014 }
3015 
3016 
3017 bool CNTV2Card::GetMixerCoefficient (const UWord inWhichMixer, ULWord & outMixCoefficient)
3018 {
3019  outMixCoefficient = 0;
3020  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3021  return false;
3022  return ReadRegister (gIndexToVidProcMixCoeffRegNum[inWhichMixer], outMixCoefficient);
3023 }
3024 
3025 
3026 bool CNTV2Card::GetMixerSyncStatus (const UWord inWhichMixer, bool & outIsSyncOK)
3027 {
3028  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3029  return false;
3030 
3031  bool syncFail (false);
3032  if (!CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], syncFail, kRegMaskVidProcSyncFail, kRegShiftVidProcSyncFail))
3033  return false;
3034  outIsSyncOK = syncFail ? false : true;
3035  return true;
3036 }
3037 
3038 bool CNTV2Card::GetMixerFGMatteEnabled (const UWord inWhichMixer, bool & outIsEnabled)
3039 {
3040  outIsEnabled = false;
3041  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3042  return false;
3043  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsEnabled, kRegMaskVidProcFGMatteEnable, kRegShiftVidProcFGMatteEnable);
3044 }
3045 
3046 bool CNTV2Card::SetMixerFGMatteEnabled (const UWord inWhichMixer, const bool inIsEnabled)
3047 {
3048  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3049  return false;
3050  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inIsEnabled?1:0, kRegMaskVidProcFGMatteEnable, kRegShiftVidProcFGMatteEnable);
3051 }
3052 
3053 bool CNTV2Card::GetMixerBGMatteEnabled (const UWord inWhichMixer, bool & outIsEnabled)
3054 {
3055  outIsEnabled = false;
3056  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3057  return false;
3058  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsEnabled, kRegMaskVidProcBGMatteEnable, kRegShiftVidProcBGMatteEnable);
3059 }
3060 
3061 bool CNTV2Card::SetMixerBGMatteEnabled (const UWord inWhichMixer, const bool inIsEnabled)
3062 {
3063  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3064  return false;
3065  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inIsEnabled?1:0, kRegMaskVidProcBGMatteEnable, kRegShiftVidProcBGMatteEnable);
3066 }
3067 
3068 static const ULWord gMatteColorRegs[] = { kRegFlatMatteValue /*13*/, kRegFlatMatte2Value /*249*/, kRegFlatMatte3Value /*487*/, kRegFlatMatte4Value /*490*/, 0, 0, 0, 0};
3069 
3070 bool CNTV2Card::GetMixerMatteColor (const UWord inWhichMixer, YCbCr10BitPixel & outYCbCrValue)
3071 {
3072  ULWord packedValue (0);
3073  outYCbCrValue.cb = outYCbCrValue.y = outYCbCrValue.cr = 0;
3074  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3075  return false;
3076  if (!ReadRegister(gMatteColorRegs[inWhichMixer], packedValue))
3077  return false;
3078 
3079  outYCbCrValue.cb = packedValue & 0x03FF;
3080  outYCbCrValue.y = ((packedValue >> 10) & 0x03FF) + 0x0040;
3081  outYCbCrValue.cr = (packedValue >> 20) & 0x03FF;
3082  return true;
3083 }
3084 
3085 bool CNTV2Card::SetMixerMatteColor (const UWord inWhichMixer, const YCbCr10BitPixel inYCbCrValue)
3086 {
3087  YCbCr10BitPixel ycbcrPixel (inYCbCrValue);
3088  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3089  return false;
3090 
3091  if (ycbcrPixel.y < 0x40)
3092  ycbcrPixel.y = 0x0; // clip y
3093  else
3094  ycbcrPixel.y -= 0x40;
3095  ycbcrPixel.y &= 0x3FF;
3096  ycbcrPixel.cb &= 0x3FF;
3097  ycbcrPixel.cr &= 0x3FF;
3098 
3099  // Pack three 10-bit values into ULWord...
3100  const ULWord packedValue (ULWord(ycbcrPixel.cb) | (ULWord(ycbcrPixel.y) << 10) | (ULWord(ycbcrPixel.cr) << 20));
3101  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": set to YCbCr=" << DEC(ycbcrPixel.y)
3102  << "|" << DEC(ycbcrPixel.cb) << "|" << DEC(ycbcrPixel.cr) << ":" << HEXN(ycbcrPixel.y,3) << "|"
3103  << HEXN(ycbcrPixel.cb,3) << "|" << HEXN(ycbcrPixel.cr,3) << ", write " << xHEX0N(packedValue,8)
3104  << " into reg " << DEC(gMatteColorRegs[inWhichMixer]));
3105 
3106  // Write it...
3107  return WriteRegister(gMatteColorRegs[inWhichMixer], packedValue);
3108 }
3109 
3110 bool CNTV2Card::MixerHasRGBModeSupport (const UWord inWhichMixer, bool & outIsSupported)
3111 {
3112  outIsSupported = false;
3113  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3114  return false;
3115  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsSupported, kRegMaskVidProcRGBModeSupported, kRegShiftVidProcRGBModeSupported);
3116 }
3117 
3118 bool CNTV2Card::SetMixerRGBRange (const UWord inWhichMixer, const NTV2MixerRGBRange inRGBRange)
3119 {
3120  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3121  return false;
3122  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inRGBRange, kRegMaskVidProcRGBRange, kRegShiftVidProcRGBRange);
3123 }
3124 
3125 bool CNTV2Card::GetMixerRGBRange (const UWord inWhichMixer, NTV2MixerRGBRange & outRGBRange)
3126 {
3127  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3128  return false;
3129  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outRGBRange, kRegMaskVidProcRGBRange, kRegShiftVidProcRGBRange);
3130 }
3131 
3132 
3134 // Mapping methods
3136 
3137 #if !defined(NTV2_DEPRECATE_16_0)
3138  // Method: GetBaseAddress
3139  // Input: NTV2Channel channel
3140  // Output: bool status and modifies ULWord **pBaseAddress
3141  bool CNTV2Card::GetBaseAddress (NTV2Channel channel, ULWord **pBaseAddress)
3142  {
3143  if (IS_CHANNEL_INVALID(channel))
3144  return false;
3145  ULWord ulFrame(0);
3146  if (!ReadRegister(gChannelToPCIAccessFrameRegNum[channel], ulFrame)) // GetPCIAccessFrame(channel, ulFrame);
3147  return false;
3148  if (ulFrame > GetNumFrameBuffers())
3149  ulFrame = 0;
3150 
3151  if (::NTV2DeviceIsDirectAddressable(GetDeviceID()))
3152  {
3153  if (!_pFrameBaseAddress)
3154  if (!MapFrameBuffers())
3155  return false;
3156  *pBaseAddress = _pFrameBaseAddress + ((ulFrame * _ulFrameBufferSize) / sizeof(ULWord));
3157  }
3158  else // must be an _MM board
3159  {
3160  if (!_pCh1FrameBaseAddress)
3161  if (!MapFrameBuffers())
3162  return false;
3163  *pBaseAddress = (channel == NTV2_CHANNEL1) ? _pCh1FrameBaseAddress : _pCh2FrameBaseAddress; // DEPRECATE!
3164  }
3165  return true;
3166  }
3167 
3168  // Method: GetBaseAddress
3169  // Input: None
3170  // Output: bool status and modifies ULWord *pBaseAddress
3171  bool CNTV2Card::GetBaseAddress (ULWord **pBaseAddress)
3172  {
3173  if (!_pFrameBaseAddress)
3174  if (!MapFrameBuffers())
3175  return false;
3176  *pBaseAddress = _pFrameBaseAddress;
3177  return true;
3178  }
3179 
3180  // Method: GetRegisterBaseAddress
3181  // Input: ULWord regNumber
3182  // Output: bool status and modifies ULWord **pBaseAddress
3183  bool CNTV2Card::GetRegisterBaseAddress (ULWord regNumber, ULWord **pBaseAddress)
3184  {
3185  if (!_pRegisterBaseAddress)
3186  if (!MapRegisters())
3187  return false;
3188  #ifdef MSWindows
3189  if ((regNumber*4) >= _pRegisterBaseAddressLength)
3190  return false;
3191  #endif // MSWindows
3192  *pBaseAddress = _pRegisterBaseAddress + regNumber;
3193  return true;
3194  }
3195 
3196  // Method: GetXena2FlashBaseAddress
3197  // Output: bool status and modifies ULWord **pXena2FlashAddress
3198  bool CNTV2Card::GetXena2FlashBaseAddress (ULWord **pXena2FlashAddress)
3199  {
3200  if (!_pXena2FlashBaseAddress)
3201  if (!MapXena2Flash())
3202  return false;
3203  *pXena2FlashAddress = _pXena2FlashBaseAddress;
3204  return true;
3205  }
3206 #endif // !defined(NTV2_DEPRECATE_16_0)
3207 
3208 bool CNTV2Card::SetDualLinkOutputEnable (const bool enable)
3209 {
3210  return WriteRegister (kRegGlobalControl, enable ? 1 : 0, kRegMaskDualLinkOutEnable, kRegShiftDualLinKOutput);
3211 }
3212 
3213 bool CNTV2Card::GetDualLinkOutputEnable (bool & outIsEnabled)
3214 {
3215  outIsEnabled = false;
3216  return CNTV2DriverInterface::ReadRegister (kRegGlobalControl, outIsEnabled, kRegMaskDualLinkOutEnable, kRegShiftDualLinKOutput);
3217 }
3218 
3219 
3220 bool CNTV2Card::SetDualLinkInputEnable (const bool enable)
3221 {
3222  return WriteRegister (kRegGlobalControl, enable ? 1 : 0, kRegMaskDualLinkInEnable, kRegShiftDualLinkInput);
3223 }
3224 
3225 
3226 bool CNTV2Card::GetDualLinkInputEnable (bool & outIsEnabled)
3227 {
3228  outIsEnabled = false;
3229  return CNTV2DriverInterface::ReadRegister (kRegGlobalControl, outIsEnabled, kRegMaskDualLinkInEnable, kRegShiftDualLinkInput);
3230 }
3231 
3232 
3234 
3235 bool CNTV2Card::SetDitherFor8BitInputs (const NTV2Channel inChannel, const ULWord inDither)
3236 {
3237  if (IS_CHANNEL_INVALID(inChannel))
3238  return false;
3239  return WriteRegister (gChannelToControlRegNum[inChannel], inDither, kRegMaskDitherOn8BitInput, kRegShiftDitherOn8BitInput);
3240 }
3241 
3242 bool CNTV2Card::GetDitherFor8BitInputs (const NTV2Channel inChannel, ULWord & outDither)
3243 {
3244  if (IS_CHANNEL_INVALID(inChannel))
3245  return false;
3246  return ReadRegister(gChannelToControlRegNum[inChannel], outDither, kRegMaskDitherOn8BitInput, kRegShiftDitherOn8BitInput);
3247 }
3248 
3250 
3251 bool CNTV2Card::SetForce64(ULWord force64) {return WriteRegister (kRegDMAControl, force64, kRegMaskForce64, kRegShiftForce64);}
3252 bool CNTV2Card::GetForce64(ULWord* force64) {return force64 ? ReadRegister (kRegDMAControl, *force64, kRegMaskForce64, kRegShiftForce64) : false;}
3253 bool CNTV2Card::Get64BitAutodetect(ULWord* autodetect64) {return autodetect64 ? ReadRegister (kRegDMAControl, *autodetect64, kRegMaskAutodetect64, kRegShiftAutodetect64) : false;}
3254 
3256 // Kona2/Xena2/ related methods
3257 
3258 // kK2RegAnalogOutControl
3259 bool CNTV2Card::SetVideoDACMode (NTV2VideoDACMode value) {return WriteRegister (kRegAnalogOutControl, value, kK2RegMaskVideoDACMode, kK2RegShiftVideoDACMode);}
3260 bool CNTV2Card::GetVideoDACMode (NTV2VideoDACMode & outValue) {return CNTV2DriverInterface::ReadRegister (kRegAnalogOutControl, outValue, kK2RegMaskVideoDACMode, kK2RegShiftVideoDACMode);}
3261 bool CNTV2Card::SetAnalogOutHTiming (ULWord value) {return WriteRegister (kRegAnalogOutControl, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3262 bool CNTV2Card::GetAnalogOutHTiming (ULWord & outValue) {return ReadRegister (kRegAnalogOutControl, outValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3263 
3264 bool CNTV2Card::SetSDIOutputStandard (const UWord inOutputSpigot, const NTV2Standard inValue)
3265 {
3266  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3267  return false;
3268 
3269  NTV2Standard standard(inValue);
3270  bool is2Kx1080(false);
3271  switch(inValue)
3272  {
3273  case NTV2_STANDARD_2Kx1080p:
3274  standard = NTV2_STANDARD_1080p;
3275  is2Kx1080 = true;
3276  break;
3277  case NTV2_STANDARD_2Kx1080i:
3278  standard = NTV2_STANDARD_1080;
3279  is2Kx1080 = true;
3280  break;
3281  case NTV2_STANDARD_3840x2160p:
3282  standard = NTV2_STANDARD_1080p;
3283  is2Kx1080 = false;
3284  break;
3285  case NTV2_STANDARD_3840HFR:
3286  standard = NTV2_STANDARD_1080p;
3287  is2Kx1080 = false;
3288  break;
3289  case NTV2_STANDARD_3840i:
3290  standard = NTV2_STANDARD_1080;
3291  is2Kx1080 = false;
3292  break;
3293  case NTV2_STANDARD_4096x2160p:
3294  standard = NTV2_STANDARD_1080p;
3295  is2Kx1080 = true;
3296  break;
3297  case NTV2_STANDARD_4096HFR:
3298  standard = NTV2_STANDARD_1080p;
3299  is2Kx1080 = true;
3300  break;
3301  case NTV2_STANDARD_4096i:
3302  standard = NTV2_STANDARD_1080;
3303  is2Kx1080 = true;
3304  break;
3305  default:
3306  break;
3307  }
3308 
3309  return WriteRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], standard, kK2RegMaskSDIOutStandard, kK2RegShiftSDIOutStandard)
3310  && SetSDIOut2Kx1080Enable(NTV2Channel(inOutputSpigot), is2Kx1080);
3311 }
3312 
3313 bool CNTV2Card::SetSDIOutputStandard (const NTV2ChannelSet & inSDIOutputs, const NTV2Standard inValue)
3314 {
3315  size_t errors(0);
3316  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
3317  if (!SetSDIOutputStandard(*it, inValue))
3318  errors++;
3319  return !errors;
3320 }
3321 
3322 bool CNTV2Card::GetSDIOutputStandard (const UWord inOutputSpigot, NTV2Standard & outValue)
3323 {
3324  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3325  return false;
3326  bool is2kx1080(false);
3327  bool is6G(false);
3328  bool is12G(false);
3329  NTV2Standard newStd(NTV2_STANDARD_INVALID);
3330  const bool result (CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], newStd, kK2RegMaskSDIOutStandard, kK2RegShiftSDIOutStandard)
3331  && GetSDIOut2Kx1080Enable(NTV2Channel(inOutputSpigot), is2kx1080)
3332  && GetSDIOut6GEnable(NTV2Channel(inOutputSpigot), is6G)
3333  && GetSDIOut12GEnable(NTV2Channel(inOutputSpigot), is12G));
3334  outValue = newStd;
3335  switch (newStd)
3336  {
3337  case NTV2_STANDARD_1080:
3338  if (is2kx1080)
3339  outValue = NTV2_STANDARD_2Kx1080i;
3340  if (is6G || is12G)
3341  outValue = is2kx1080 ? NTV2_STANDARD_4096i : NTV2_STANDARD_3840i;
3342  break;
3343  case NTV2_STANDARD_1080p:
3344  if (is2kx1080)
3345  outValue = NTV2_STANDARD_2Kx1080p;
3346  if (is6G || is12G)
3347  outValue = is2kx1080 ? NTV2_STANDARD_4096x2160p : NTV2_STANDARD_3840x2160p;
3348  break;
3349  default:
3350  break;
3351  }
3352  return result;
3353 }
3354 
3355 bool CNTV2Card::WriteOutputTimingControl (const ULWord inValue, const UWord inOutputSpigot)
3356 {
3357  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3358  return false;
3359  if (IsMultiFormatActive())
3360  return WriteRegister (gChannelToOutputTimingCtrlRegNum[inOutputSpigot], inValue);
3361  else if (IsSupported(kDeviceCanDoMultiFormat))
3362  {
3363  // Write all of the timing registers for UniFormat mode...
3364  switch (GetNumSupported(kDeviceGetNumVideoChannels))
3365  {
3366  case 8:
3367  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL8], inValue);
3368  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL7], inValue);
3369  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL6], inValue);
3370  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL5], inValue);
3371  AJA_FALL_THRU;
3372  case 4:
3373  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL4], inValue);
3374  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL3], inValue);
3375  AJA_FALL_THRU;
3376  case 2:
3377  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL2], inValue);
3378  AJA_FALL_THRU;
3379  default:
3380  return WriteRegister (gChannelToOutputTimingCtrlRegNum [NTV2_CHANNEL1], inValue);
3381  }
3382  }
3383  else
3384  return WriteRegister (gChannelToOutputTimingCtrlRegNum [NTV2_CHANNEL1], inValue);
3385 }
3386 
3387 
3388 bool CNTV2Card::ReadOutputTimingControl (ULWord & outValue, const UWord inOutputSpigot)
3389 {
3390  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
3391  return false;
3392  return ReadRegister (gChannelToOutputTimingCtrlRegNum[IsMultiFormatActive() ? inOutputSpigot : UWord(NTV2_CHANNEL1)], outValue);
3393 }
3394 
3395 // SDI1 HTiming
3396 bool CNTV2Card::SetSDI1OutHTiming (ULWord value) {return WriteRegister (kRegSDIOut1Control, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3397 bool CNTV2Card::GetSDI1OutHTiming(ULWord* pValue) {return pValue ? ReadRegister(kRegSDIOut1Control, *pValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming) : false;}
3398 
3399 // SDI2 HTiming
3400 bool CNTV2Card::SetSDI2OutHTiming (ULWord value) {return WriteRegister (kRegSDIOut2Control, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3401 bool CNTV2Card::GetSDI2OutHTiming(ULWord* pValue) {return pValue ? ReadRegister(kRegSDIOut2Control, *pValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming) : false;}
3402 
3403 bool CNTV2Card::SetSecondaryVideoFormat(NTV2VideoFormat format)
3404 {
3405  return WriteRegister(kVRegSecondaryFormatSelect, format);
3406 }
3407 
3408 bool CNTV2Card::GetSecondaryVideoFormat(NTV2VideoFormat & outFormat)
3409 {
3410  return CNTV2DriverInterface::ReadRegister (kVRegSecondaryFormatSelect, outFormat);
3411 }
3412 
3413 
3414 #if !defined(R2_DEPRECATE)
3415 
3416 bool CNTV2Card::SetInputVideoSelect (NTV2InputVideoSelect input)
3417 {
3418  return WriteRegister(kVRegInputSelect, input);
3419 }
3420 
3421 bool CNTV2Card::GetInputVideoSelect(NTV2InputVideoSelect & outInputSelect)
3422 {
3423  return CNTV2DriverInterface::ReadRegister(kVRegInputSelect, outInputSelect);
3424 }
3425 
3426 #endif // R2_DEPRECATE
3427 
3428 
3429 NTV2VideoFormat CNTV2Card::GetInputVideoFormat (NTV2InputSource inSource, const bool inIsProgressivePicture)
3430 {
3431  switch (inSource)
3432  {
3433  case NTV2_INPUTSOURCE_SDI1: return GetSDIInputVideoFormat (NTV2_CHANNEL1, inIsProgressivePicture);
3434  case NTV2_INPUTSOURCE_SDI2: return GetSDIInputVideoFormat (NTV2_CHANNEL2, inIsProgressivePicture);
3435  case NTV2_INPUTSOURCE_SDI3: return GetSDIInputVideoFormat (NTV2_CHANNEL3, inIsProgressivePicture);
3436  case NTV2_INPUTSOURCE_SDI4: return GetSDIInputVideoFormat (NTV2_CHANNEL4, inIsProgressivePicture);
3437  case NTV2_INPUTSOURCE_SDI5: return GetSDIInputVideoFormat (NTV2_CHANNEL5, inIsProgressivePicture);
3438  case NTV2_INPUTSOURCE_SDI6: return GetSDIInputVideoFormat (NTV2_CHANNEL6, inIsProgressivePicture);
3439  case NTV2_INPUTSOURCE_SDI7: return GetSDIInputVideoFormat (NTV2_CHANNEL7, inIsProgressivePicture);
3440  case NTV2_INPUTSOURCE_SDI8: return GetSDIInputVideoFormat (NTV2_CHANNEL8, inIsProgressivePicture);
3441  case NTV2_INPUTSOURCE_HDMI1: return GetHDMIInputVideoFormat (NTV2_CHANNEL1);
3442  case NTV2_INPUTSOURCE_HDMI2: return GetHDMIInputVideoFormat (NTV2_CHANNEL2);
3443  case NTV2_INPUTSOURCE_HDMI3: return GetHDMIInputVideoFormat (NTV2_CHANNEL3);
3444  case NTV2_INPUTSOURCE_HDMI4: return GetHDMIInputVideoFormat (NTV2_CHANNEL4);
3445  case NTV2_INPUTSOURCE_ANALOG1: return GetAnalogInputVideoFormat ();
3446  default: return NTV2_FORMAT_UNKNOWN;
3447  }
3448 }
3449 
3450 NTV2VideoFormat CNTV2Card::GetSDIInputVideoFormat (NTV2Channel inChannel, bool inIsProgressivePicture)
3451 {
3452  ULWord vpidDS1(0), vpidDS2(0);
3453  CNTV2VPID inputVPID;
3454  if (IS_CHANNEL_INVALID(inChannel))
3455  return NTV2_FORMAT_UNKNOWN;
3456 
3457  bool isValidVPID (GetVPIDValidA(inChannel));
3458  if (isValidVPID)
3459  {
3460  ReadSDIInVPID(inChannel, vpidDS1, vpidDS2);
3461  inputVPID.SetVPID(vpidDS1);
3462  isValidVPID = inputVPID.IsValid();
3463  }
3464 
3465  NTV2FrameRate inputRate(GetSDIInputRate(inChannel));
3466  NTV2FrameGeometry inputGeometry(GetSDIInputGeometry(inChannel));
3467  bool isProgressiveTrans (isValidVPID ? inputVPID.GetProgressiveTransport() : GetSDIInputIsProgressive(inChannel));
3468  bool isProgressivePic (isValidVPID ? inputVPID.GetProgressivePicture() : inIsProgressivePicture);
3469  bool isInput3G (false);
3470 
3471  if(inputRate == NTV2_FRAMERATE_INVALID)
3472  return NTV2_FORMAT_UNKNOWN;
3473 
3474  const ULWordSet wgtIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
3475  const bool canDo292In (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn, inChannel)) != wgtIDs.end());
3476  const bool canDo3GIn (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn3G, inChannel)) != wgtIDs.end());
3477  const bool canDo12GIn (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn12G, inChannel)) != wgtIDs.end());
3478 
3479  if (canDo3GIn || canDo12GIn)
3480  {
3481  GetSDIInput3GPresent(isInput3G, inChannel);
3482  NTV2VideoFormat format = isValidVPID ? inputVPID.GetVideoFormat() : GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3483  if (isValidVPID && format == NTV2_FORMAT_UNKNOWN)
3484  {
3485  // Something might be incorrect in VPID
3486  isProgressiveTrans = GetSDIInputIsProgressive(inChannel);
3487  isProgressivePic = inIsProgressivePicture;
3488  format = GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3489  }
3490  if (canDo12GIn && format != NTV2_FORMAT_UNKNOWN && !isValidVPID)
3491  {
3492  bool is6G(false), is12G(false);
3493  GetSDIInput6GPresent(is6G, inChannel);
3494  GetSDIInput12GPresent(is12G, inChannel);
3495  if (is6G || is12G)
3496  {
3497  format = GetQuadSizedVideoFormat(format, !IsSupported(kDeviceCanDo12gRouting) ? true : false);
3498  }
3499  if (inputVPID.IsStandardMultiLink4320())
3500  {
3501  format = GetQuadSizedVideoFormat(format, true);
3502  }
3503  }
3504  return format;
3505  }
3506 
3507  if (canDo292In)
3508  {
3509  if (_boardID == DEVICE_ID_KONALHI || _boardID == DEVICE_ID_KONALHIDVI)
3510  {
3511  GetSDIInput3GPresent(isInput3G, NTV2_CHANNEL1);
3512  }
3513  return GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3514  }
3515 
3516  return NTV2_FORMAT_UNKNOWN;
3517 }
3518 
3519 
3520 NTV2VideoFormat CNTV2Card::GetHDMIInputVideoFormat(NTV2Channel inChannel)
3521 {
3522  NTV2VideoFormat format = NTV2_FORMAT_UNKNOWN;
3523  ULWord status;
3524  if (GetHDMIInputStatus(status, inChannel))
3525  {
3526  if ( (status & kRegMaskInputStatusLock) != 0 )
3527  {
3528  ULWord hdmiVersion = GetNumSupported(kDeviceGetHDMIVersion);
3529  if(hdmiVersion == 1)
3530  {
3531  ULWord standard = ((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd);
3532  if(standard == 0x5) // NTV2_STANDARD_2K (2048x1556psf) in HDMI is really SXGA!!
3533  {
3534  // We return 1080p60 for SXGA format
3535  return NTV2_FORMAT_1080p_6000_A;
3536  }
3537  else
3538  {
3539  format = GetNTV2VideoFormat (NTV2FrameRate((status & kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS),
3540  NTV2Standard((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd),
3541  false, // 3G
3542  0, // input geometry
3543  false); // progressive picture
3544  }
3545  }
3546  else if(hdmiVersion > 1)
3547  {
3548  bool squareDivision = hdmiVersion == 5 ? false : true;
3549  NTV2FrameRate hdmiRate = NTV2FrameRate((status &kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS);
3550  NTV2Standard hdmiStandard = NTV2Standard((status & kRegMaskHDMIInV2VideoStd) >> kRegShiftHDMIInV2VideoStd);
3551  UByte inputGeometry = 0;
3552  if (hdmiStandard == NTV2_STANDARD_2Kx1080i || hdmiStandard == NTV2_STANDARD_2Kx1080p)
3553  inputGeometry = 8;
3554  format = GetNTV2VideoFormat (hdmiRate, hdmiStandard, false, inputGeometry, false, squareDivision);
3555  }
3556  }
3557  }
3558  return format;
3559 }
3560 
3561 NTV2VideoFormat CNTV2Card::GetAnalogInputVideoFormat()
3562 {
3563  NTV2VideoFormat format = NTV2_FORMAT_UNKNOWN;
3564  ULWord status;
3565  if (ReadRegister(kRegAnalogInputStatus, status))
3566  {
3567  if ( (status & kRegMaskInputStatusLock) != 0 )
3568  format = GetNTV2VideoFormat ( NTV2FrameRate((status & kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS),
3569  NTV2Standard ((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd),
3570  false, // 3G
3571  0, // input geometry
3572  false); // progressive picture
3573  }
3574  return format;
3575 }
3576 
3577 NTV2VideoFormat CNTV2Card::GetAnalogCompositeInputVideoFormat (void)
3578 {
3579  NTV2VideoFormat format(NTV2_FORMAT_UNKNOWN);
3580  ULWord analogDetect(0);
3581  // Use a single (atomic) read... so we don't return a bogus value if the register is changing while we're in here!
3582  if (ReadRegister(kRegAnalogInputStatus, analogDetect))
3583  {
3584  const ULWord locked ((analogDetect & kRegMaskAnalogCompositeLocked) >> kRegShiftAnalogCompositeLocked);
3585  if (locked)
3586  {
3587  const ULWord Pal ((analogDetect & kRegMaskAnalogCompositeFormat625) >> kRegShiftAnalogCompositeFormat625);
3588  // Validate NTSC/PAL reading with Frame Rate Family
3589  const ULWord integerRate ((analogDetect & kRegMaskAnalogInputIntegerRate) >> kRegShiftAnalogInputIntegerRate);
3590  if (Pal)
3591  {
3592  if (integerRate)
3593  format = NTV2_FORMAT_625_5000;
3594  else
3595  format = NTV2_FORMAT_UNKNOWN; // illegal combination - 625/59.94
3596  }
3597  else
3598  {
3599  if (integerRate)
3600  format = NTV2_FORMAT_UNKNOWN; // illegal combination - 525/60
3601  else
3602  format = NTV2_FORMAT_525_5994;
3603  }
3604  }
3605  }
3606  return format;
3607 }
3608 
3609 
3610 NTV2VideoFormat CNTV2Card::GetReferenceVideoFormat (void)
3611 {
3612  ULWord status(0);
3613  if (!ReadRegister(kRegInputStatus, status))
3614  return NTV2_FORMAT_UNKNOWN;
3615  return GetNTV2VideoFormat (NTV2FrameRate((status >> 16) & 0xF), // frame rate
3616  ((status >> 20) & 0x7), // input scan geometry
3617  (status & BIT_23) ? true : false, // progressive transport
3618  false, // 3G
3619  false); // progressive picture
3620 }
3621 
3622 NTV2FrameRate CNTV2Card::GetSDIInputRate (const NTV2Channel channel)
3623 {
3624  if (IS_CHANNEL_INVALID (channel))
3625  return NTV2_FRAMERATE_INVALID;
3626 
3627  ULWord rateLow (0), rateHigh (0);
3628  NTV2FrameRate currentRate (NTV2_FRAMERATE_INVALID);
3629  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], rateLow,
3630  gChannelToSDIInputRateMask[channel], gChannelToSDIInputRateShift[channel]))
3631  return NTV2_FRAMERATE_INVALID;
3632  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], rateHigh,
3633  gChannelToSDIInputRateHighMask[channel], gChannelToSDIInputRateHighShift[channel]))
3634  return NTV2_FRAMERATE_INVALID;
3635  currentRate = NTV2FrameRate(((rateHigh << 3) & BIT_3) | rateLow);
3636  return NTV2_IS_VALID_NTV2FrameRate(currentRate) ? currentRate : NTV2_FRAMERATE_INVALID;
3637 } // GetSDIInputRate
3638 
3639 NTV2FrameGeometry CNTV2Card::GetSDIInputGeometry (const NTV2Channel channel)
3640 {
3641  if (IS_CHANNEL_INVALID (channel))
3642  return NTV2_FG_INVALID;
3643 
3644  ULWord geometryLow (0), geometryHigh (0);
3645  NTV2FrameGeometry currentGeometry (NTV2_FG_INVALID);
3646  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], geometryLow,
3647  gChannelToSDIInputGeometryMask[channel], gChannelToSDIInputGeometryShift[channel]))
3648  return NTV2_FG_INVALID;
3649  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], geometryHigh,
3650  gChannelToSDIInputGeometryHighMask[channel], gChannelToSDIInputGeometryHighShift[channel]))
3651  return NTV2_FG_INVALID;
3652  currentGeometry = NTV2FrameGeometry(((geometryHigh << 3) & BIT_3) | geometryLow);
3653  return NTV2_IS_VALID_NTV2FrameGeometry(currentGeometry) ? currentGeometry : NTV2_FG_INVALID;
3654 } // GetSDIInputGeometry
3655 
3656 bool CNTV2Card::GetSDIInputIsProgressive (const NTV2Channel channel)
3657 {
3658  if (IS_CHANNEL_INVALID (channel))
3659  return false;
3660 
3661  ULWord isProgressive = 0;
3662  ReadRegister(gChannelToSDIInputStatusRegNum[channel], isProgressive, gChannelToSDIInputProgressiveMask[channel], gChannelToSDIInputProgressiveShift[channel]);
3663  return isProgressive ? true : false;
3664 } // GetSDIInputIsProgressive
3665 
3666 bool CNTV2Card::GetSDIInput3GPresent (bool & outValue, const NTV2Channel channel)
3667 {
3668  if (IS_CHANNEL_INVALID (channel))
3669  return false;
3670 
3671  ULWord value (0);
3672  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn3GModeMask[channel], gChannelToSDIIn3GModeShift[channel]));
3673  outValue = static_cast <bool> (value);
3674  return result;
3675 
3676 } // GetSDIInput3GPresent
3677 
3678 bool CNTV2Card::GetSDIInput3GbPresent (bool & outValue, const NTV2Channel channel)
3679 {
3680  if (IS_CHANNEL_INVALID (channel))
3681  return false;
3682 
3683  ULWord value (0);
3684  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn3GbModeMask[channel], gChannelToSDIIn3GbModeShift[channel]));
3685  outValue = static_cast <bool> (value);
3686  return result;
3687 
3688 } // GetSDIInput3GPresent
3689 
3690 bool CNTV2Card::GetSDIInput6GPresent (bool & outValue, const NTV2Channel channel)
3691 {
3692  if (IS_CHANNEL_INVALID (channel))
3693  return false;
3694 
3695  ULWord value (0);
3696  bool result (ReadRegister (gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn6GModeMask[channel], gChannelToSDIIn6GModeShift[channel]));
3697  outValue = static_cast <bool> (value);
3698  return result;
3699 
3700 } // GetSDIInput3GPresent
3701 
3702 bool CNTV2Card::GetSDIInput12GPresent (bool & outValue, const NTV2Channel channel)
3703 {
3704  if (IS_CHANNEL_INVALID (channel))
3705  return false;
3706 
3707  ULWord value (0);
3708  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn12GModeMask[channel], gChannelToSDIIn12GModeShift[channel]));
3709  outValue = static_cast <bool> (value);
3710  return result;
3711 
3712 } // GetSDIInput3GPresent
3713 
3714 
3715 bool CNTV2Card::SetLTCInputEnable (bool inEnable)
3716 {
3717  if (GetDeviceID() == DEVICE_ID_CORVID24)
3718  inEnable = !inEnable; // Oops, Corvid24's LTCOnRefInSelect bit sense was flipped
3719  return WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kFS1RefMaskLTCOnRefInSelect, kFS1RefShiftLTCOnRefInSelect)
3720  && WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kRegMaskLTCOnRefInSelect, kRegShiftLTCOnRefInSelect);
3721 }
3722 
3723 bool CNTV2Card::GetLTCInputEnable (bool & outIsEnabled)
3724 {
3725  if (!CNTV2DriverInterface::ReadRegister (kRegFS1ReferenceSelect, outIsEnabled, kFS1RefMaskLTCOnRefInSelect, kFS1RefShiftLTCOnRefInSelect))
3726  return false;
3727  if (GetDeviceID() == DEVICE_ID_CORVID24)
3728  outIsEnabled = !outIsEnabled; // Oops, Corvid24's LTCOnRefInSelect bit sense was flipped
3729  return true;
3730 }
3731 
3732 bool CNTV2Card::GetLTCInputPresent (bool & outIsPresent, const UWord inLTCInputNdx)
3733 {
3734  if (ULWord(inLTCInputNdx) >= GetNumSupported(kDeviceGetNumLTCInputs))
3735  return false; // No such LTC input
3736  if (inLTCInputNdx) // LTCIn2
3737  return CNTV2DriverInterface::ReadRegister (kRegLTCStatusControl, outIsPresent, kRegMaskLTC2InPresent, kRegShiftLTC2InPresent);
3738  else // LTCIn1
3739  {
3740  CNTV2DriverInterface::ReadRegister (kRegStatus, outIsPresent, kRegMaskLTCInPresent, kRegShiftLTCInPresent);
3741  if(outIsPresent)
3742  return true;
3743  return CNTV2DriverInterface::ReadRegister (kRegLTCStatusControl, outIsPresent, kRegMaskLTC1InPresent, kRegShiftLTC1InPresent);
3744  }
3745 }
3746 
3747 #if !defined(NTV2_DEPRECATE_16_3)
3748  bool CNTV2Card::SetLTCEmbeddedOutEnable (const bool inEnable)
3749  {
3750  return WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kFS1RefMaskLTCEmbeddedOutEnable, kFS1RefShiftLTCEmbeddedOutEnable);
3751  }
3752 
3753  bool CNTV2Card::GetLTCEmbeddedOutEnable (bool & outEnabled)
3754  {
3755  return CNTV2DriverInterface::ReadRegister (kRegFS1ReferenceSelect, outEnabled, kFS1RefMaskLTCEmbeddedOutEnable, kFS1RefShiftLTCEmbeddedOutEnable);
3756  }
3757 #endif // !defined(NTV2_DEPRECATE_16_3)
3758 
3759 bool CNTV2Card::ReadAnalogLTCInput (const UWord inLTCInput, RP188_STRUCT & outRP188Data)
3760 {
3761  NTV2_RP188 result;
3762  if (!ReadAnalogLTCInput(inLTCInput, result))
3763  return false;
3764  outRP188Data = result;
3765  return true;
3766 }
3767 
3768 
3769 bool CNTV2Card::ReadAnalogLTCInput (const UWord inLTCInput, NTV2_RP188 & outRP188Data)
3770 {
3771  outRP188Data.Set();
3772  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3773  return false;
3774 
3775  const ULWord regLo (inLTCInput ? kRegLTC2AnalogBits0_31 : kRegLTCAnalogBits0_31 );
3776  const ULWord regHi (inLTCInput ? kRegLTC2AnalogBits32_63 : kRegLTCAnalogBits32_63);
3777  outRP188Data.fDBB = 0;
3778  return ReadRegister(regLo, outRP188Data.fLo) && ReadRegister(regHi, outRP188Data.fHi);
3779 }
3780 
3781 
3782 bool CNTV2Card::GetAnalogLTCInClockChannel (const UWord inLTCInput, NTV2Channel & outChannel)
3783 {
3784  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3785  return false;
3786 
3787  ULWord value(0);
3788  if (!ReadRegister (kRegLTCStatusControl, value, 0x7, inLTCInput ? 9 : 1)) // Bits 1|2|3 for LTCIn1, bits 9|10|11 for LTCIn2
3789  return false;
3790  outChannel = NTV2Channel(value + 1);
3791  return true;
3792 }
3793 
3794 
3795 bool CNTV2Card::SetAnalogLTCInClockChannel (const UWord inLTCInput, const NTV2Channel inChannel)
3796 {
3797  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3798  return false;
3799  if (IS_CHANNEL_INVALID(inChannel))
3800  return false;
3801  return WriteRegister (kRegLTCStatusControl, inChannel - 1, 0x7, inLTCInput ? 9 : 1); // Bits 1|2|3 for LTCIn1, bits 9|10|11 for LTCIn2
3802 }
3803 
3804 
3805 bool CNTV2Card::WriteAnalogLTCOutput (const UWord inLTCOutput, const RP188_STRUCT & inRP188Data)
3806 {
3807  const NTV2_RP188 rp188data(inRP188Data);
3808  return WriteAnalogLTCOutput (inLTCOutput, rp188data);
3809 }
3810 
3811 
3812 bool CNTV2Card::WriteAnalogLTCOutput (const UWord inLTCOutput, const NTV2_RP188 & inRP188Data)
3813 {
3814  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3815  return false;
3816 
3817  return WriteRegister (inLTCOutput == 0 ? kRegLTCAnalogBits0_31 : kRegLTC2AnalogBits0_31, inRP188Data.fLo)
3818  && WriteRegister (inLTCOutput == 0 ? kRegLTCAnalogBits32_63 : kRegLTC2AnalogBits32_63, inRP188Data.fHi);
3819 }
3820 
3821 
3822 bool CNTV2Card::GetAnalogLTCOutClockChannel (const UWord inLTCOutput, NTV2Channel & outChannel)
3823 {
3824  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3825  return false;
3826 
3827  ULWord value(0);
3828  bool isMultiFormat(false);
3829  if (!GetMultiFormatMode(isMultiFormat))
3830  return false;
3831  if (!isMultiFormat)
3832  return false;
3833  if (!ReadRegister(kRegLTCStatusControl, value, 0x7, inLTCOutput ? 20 : 16)) // Bits 16|17|18 for LTCOut1, bits 20|21|22 for LTCOut2
3834  return false;
3835  outChannel = NTV2Channel(value + 1);
3836  return true;
3837 }
3838 
3839 
3840 bool CNTV2Card::SetAnalogLTCOutClockChannel (const UWord inLTCOutput, const NTV2Channel inChannel)
3841 {
3842  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3843  return false;
3844  if (IS_CHANNEL_INVALID (inChannel))
3845  return false;
3846  bool isMultiFormat(false);
3847  if (!GetMultiFormatMode(isMultiFormat))
3848  return false;
3849  if (!isMultiFormat)
3850  return false;
3851  return WriteRegister (kRegLTCStatusControl, inChannel - 1, 0x7, inLTCOutput ? 20 : 16); // Bits 16|17|18 for LTCOut1, bits 20|21|22 for LTCOut2
3852 }
3853 
3854 
3855 static const ULWord sSDIXmitEnableMasks[] = { kRegMaskSDI1Transmit, kRegMaskSDI2Transmit, kRegMaskSDI3Transmit, ULWord(kRegMaskSDI4Transmit),
3856  kRegMaskSDI5Transmit, kRegMaskSDI6Transmit, kRegMaskSDI7Transmit, kRegMaskSDI8Transmit};
3857 static const ULWord sSDIXmitEnableShifts[] = { kRegShiftSDI1Transmit, kRegShiftSDI2Transmit, kRegShiftSDI3Transmit, kRegShiftSDI4Transmit,
3858  kRegShiftSDI5Transmit, kRegShiftSDI6Transmit, kRegShiftSDI7Transmit, kRegShiftSDI8Transmit};
3859 
3860 bool CNTV2Card::SetSDITransmitEnable (const NTV2Channel inChannel, const bool inEnable)
3861 {
3862  if (IS_CHANNEL_INVALID(inChannel))
3863  return false; // bad channel
3864  if (!IsSupported(kDeviceHasBiDirectionalSDI))
3865  return true; // no bidirectional SDI, OK
3866  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3867  return false; // no such SDI connector
3868  const ULWord mask(sSDIXmitEnableMasks[inChannel]), shift(sSDIXmitEnableShifts[inChannel]);
3869  return WriteRegister(kRegSDITransmitControl, ULWord(inEnable), mask, shift);
3870 }
3871 
3872 bool CNTV2Card::SetSDITransmitEnable (const NTV2ChannelSet & inSDIConnectors, const bool inEnable)
3873 {
3874  UWord failures(0);
3875  for (NTV2ChannelSetConstIter it(inSDIConnectors.begin()); it != inSDIConnectors.end(); ++it)
3876  if (!SetSDITransmitEnable(*it, inEnable))
3877  failures++;
3878  return !failures;
3879 }
3880 
3881 bool CNTV2Card::GetSDITransmitEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3882 {
3883  if (IS_CHANNEL_INVALID(inChannel))
3884  return false; // invalid channel
3885  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3886  return false; // no such SDI connector
3887  if (!IsSupported(kDeviceHasBiDirectionalSDI))
3888  {outIsEnabled = true; return true;} // no bidirectional SDI, enabled, OK
3889  const ULWord mask(sSDIXmitEnableMasks[inChannel]), shift(sSDIXmitEnableShifts[inChannel]);
3890  return CNTV2DriverInterface::ReadRegister (kRegSDITransmitControl, outIsEnabled, mask, shift);
3891 }
3892 
3893 bool CNTV2Card::GetTransmitSDIs (NTV2ChannelSet & outXmitSDIs)
3894 {
3895  outXmitSDIs.clear();
3896  const bool biDirectionalSDI (IsSupported(kDeviceHasBiDirectionalSDI));
3897  const NTV2Channel maxCh(NTV2Channel(GetNumSupported(kDeviceGetNumVideoOutputs)));
3898  bool isXmit(false);
3899  for (NTV2Channel ch(NTV2_CHANNEL1); ch < maxCh; ch = NTV2Channel(ch+1))
3900  if (!biDirectionalSDI || (GetSDITransmitEnable(ch, isXmit) && isXmit))
3901  outXmitSDIs.insert(ch);
3902  return true;
3903 }
3904 
3905 
3906 bool CNTV2Card::SetSDIOut2Kx1080Enable (NTV2Channel inChannel, const bool inIsEnabled)
3907 {
3908  if (IS_CHANNEL_INVALID (inChannel))
3909  return false;
3910  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inIsEnabled, kK2RegMaskSDI1Out_2Kx1080Mode, kK2RegShiftSDI1Out_2Kx1080Mode);
3911 }
3912 
3913 bool CNTV2Card::GetSDIOut2Kx1080Enable(NTV2Channel inChannel, bool & outIsEnabled)
3914 {
3915  if (IS_CHANNEL_INVALID (inChannel))
3916  return false;
3917  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kK2RegMaskSDI1Out_2Kx1080Mode, kK2RegShiftSDI1Out_2Kx1080Mode);
3918 }
3919 
3920 bool CNTV2Card::SetSDIOut3GEnable (const NTV2Channel inChannel, const bool inEnable)
3921 {
3922  if (IS_CHANNEL_INVALID(inChannel))
3923  return false;
3924  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inEnable, kLHIRegMaskSDIOut3GbpsMode, kLHIRegShiftSDIOut3GbpsMode);
3925 }
3926 
3927 bool CNTV2Card::GetSDIOut3GEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3928 {
3929  if (IS_CHANNEL_INVALID(inChannel))
3930  return false;
3931  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kLHIRegMaskSDIOut3GbpsMode, kLHIRegShiftSDIOut3GbpsMode);
3932 }
3933 
3934 
3935 bool CNTV2Card::SetSDIOut3GbEnable (const NTV2Channel inChannel, const bool inEnable)
3936 {
3937  if (IS_CHANNEL_INVALID(inChannel))
3938  return false;
3939  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inEnable, kLHIRegMaskSDIOutSMPTELevelBMode, kLHIRegShiftSDIOutSMPTELevelBMode);
3940 }
3941 
3942 bool CNTV2Card::GetSDIOut3GbEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3943 {
3944  if (IS_CHANNEL_INVALID(inChannel))
3945  return false;
3946  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kLHIRegMaskSDIOutSMPTELevelBMode, kLHIRegShiftSDIOutSMPTELevelBMode);
3947 }
3948 
3949 bool CNTV2Card::SetSDIOut6GEnable (const NTV2Channel inChannel, const bool inEnable)
3950 {
3951  if (IS_CHANNEL_INVALID(inChannel))
3952  return false;
3953  const NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3954  if (inEnable)
3955  WriteRegister(gChannelToSDIOutControlRegNum[channel], 0, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3956  return WriteRegister(gChannelToSDIOutControlRegNum[channel], inEnable, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode);
3957 }
3958 
3959 bool CNTV2Card::GetSDIOut6GEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3960 {
3961  if (IS_CHANNEL_INVALID(inChannel))
3962  return false;
3963  bool is6G(false), is12G(false);
3964  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3965  const bool result (CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], is6G, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode)
3966  && CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], is12G, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode));
3967  if (is6G && !is12G)
3968  outIsEnabled = true;
3969  else
3970  outIsEnabled = false;
3971  return result;
3972 }
3973 
3974 bool CNTV2Card::SetSDIOut12GEnable (const NTV2Channel inChannel, const bool inEnable)
3975 {
3976  if (IS_CHANNEL_INVALID(inChannel))
3977  return false;
3978  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3979  if (inEnable)
3980  WriteRegister(gChannelToSDIOutControlRegNum[channel], 0, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode);
3981  return WriteRegister(gChannelToSDIOutControlRegNum[channel], inEnable, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3982 }
3983 
3984 bool CNTV2Card::GetSDIOut12GEnable(const NTV2Channel inChannel, bool & outIsEnabled)
3985 {
3986  if (IS_CHANNEL_INVALID(inChannel))
3987  return false;
3988  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3989  return CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], outIsEnabled, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3990 }
3991 
3992 
3993 bool CNTV2Card::GetSDIOutputAudioSystem (const NTV2Channel inChannel, NTV2AudioSystem & outAudioSystem)
3994 {
3995  outAudioSystem = NTV2_AUDIOSYSTEM_INVALID;
3996  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3997  return false; // illegal channel
3998 
3999  ULWord readVal;
4000  const ULWord regNum (gChannelToSDIOutControlRegNum[inChannel]);
4001  if (!ReadRegister (regNum, readVal, kK2RegMaskSDIOutDS1AudioSelect, kK2RegShiftSDIOutDS1AudioSelect))
4002  return false;
4003 
4004  readVal <<= kK2RegShiftSDIOutDS1AudioSelect;
4005  ULWord b2 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit2) ? 1 : 0;
4006  ULWord b1 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit1) ? 1 : 0;
4007  ULWord b0 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit0) ? 1 : 0;
4008 
4009  outAudioSystem = NTV2AudioSystem(b2 * 4 + b1 * 2 + b0);
4010  return true;
4011 
4012 } // GetSDIOutputAudioSystem
4013 
4014 
4015 bool CNTV2Card::SetSDIOutputAudioSystem (const NTV2Channel inChannel, const NTV2AudioSystem inAudioSystem)
4016 {
4017 
4018  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4019  return false; // Invalid channel
4020  if (ULWord(inAudioSystem) >= GetNumSupported(kDeviceGetTotalNumAudioSystems))
4021  return false; // Invalid audio system
4022 
4023  // shift each bit from it's position in inAudioSystem to it's position in the register
4024  // bit 18 (MSB), bit 28, bit 30 (LSB)
4025  ULWord b2 = (inAudioSystem << 16) & kK2RegMaskSDIOutDS1Audio_Bit2;
4026  ULWord b1 = (inAudioSystem << 27) & kK2RegMaskSDIOutDS1Audio_Bit1;
4027  ULWord b0 = (inAudioSystem << 30) & kK2RegMaskSDIOutDS1Audio_Bit0;
4028 
4029  return WriteRegister (gChannelToSDIOutControlRegNum [inChannel], (b2 | b1 | b0) >> kK2RegShiftSDIOutDS1AudioSelect ,
4030  kK2RegMaskSDIOutDS1AudioSelect, kK2RegShiftSDIOutDS1AudioSelect);
4031 
4032 } // SetSDIOutputAudioSystem
4033 
4034 
4035 bool CNTV2Card::SetSDIOutputAudioSystem (const NTV2ChannelSet & inSDIOutputs, const NTV2AudioSystem inAudioSystem, const bool inDS2)
4036 {
4037  size_t numFailures(0);
4038  for (NTV2ChannelSet::const_iterator it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4039  if (!(inDS2 ? SetSDIOutputDS2AudioSystem(*it, inAudioSystem) : SetSDIOutputAudioSystem(*it, inAudioSystem)))
4040  numFailures++;
4041  return numFailures == 0;
4042 }
4043 
4044 
4045 bool CNTV2Card::GetSDIOutputDS2AudioSystem (const NTV2Channel inChannel, NTV2AudioSystem & outAudioSystem)
4046 {
4047  outAudioSystem = NTV2_AUDIOSYSTEM_INVALID;
4048  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4049  return false; // illegal channel
4050 
4051  ULWord readVal;
4052  const ULWord regNum (gChannelToSDIOutControlRegNum[inChannel]);
4053  if (!ReadRegister (regNum, readVal, kK2RegMaskSDIOutDS2AudioSelect, kK2RegShiftSDIOutDS2AudioSelect))
4054  return false;
4055 
4056  readVal <<= kK2RegShiftSDIOutDS2AudioSelect;
4057  ULWord b2 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit2) ? 1 : 0;
4058  ULWord b1 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit1) ? 1 : 0;
4059  ULWord b0 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit0) ? 1 : 0;
4060 
4061  outAudioSystem = NTV2AudioSystem(b2 * 4 + b1 * 2 + b0);
4062  return true;
4063 
4064 } // GetSDIOutputDS2AudioSystem
4065 
4066 
4067 bool CNTV2Card::SetSDIOutputDS2AudioSystem (const NTV2Channel inChannel, const NTV2AudioSystem inAudioSystem)
4068 {
4069  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4070  return false; // Invalid channel
4071  if (ULWord(inAudioSystem) >= GetNumSupported(kDeviceGetTotalNumAudioSystems))
4072  return false; // Invalid audio system
4073 
4074  // shift each bit from it's position in inAudioSystem to it's position in the register
4075  // bit 19 (MSB), bit 29, bit 31 (LSB)
4076  ULWord b2 = (inAudioSystem << 17) & kK2RegMaskSDIOutDS2Audio_Bit2;
4077  ULWord b1 = (inAudioSystem << 28) & kK2RegMaskSDIOutDS2Audio_Bit1;
4078  ULWord b0 = (inAudioSystem << 31) & kK2RegMaskSDIOutDS2Audio_Bit0;
4079 
4080  return WriteRegister (gChannelToSDIOutControlRegNum [inChannel], (b2 | b1 | b0) >> kK2RegShiftSDIOutDS2AudioSelect ,
4081  kK2RegMaskSDIOutDS2AudioSelect, kK2RegShiftSDIOutDS2AudioSelect);
4082 
4083 } // SetSDIOutputDS2AudioSystem
4084 
4085 
4086 // SDI bypass relay control
4087 static bool WriteWatchdogControlBit (CNTV2Card & card, const ULWord inValue, const ULWord inMask, const ULWord inShift)
4088 {
4089  if (!card.KickSDIWatchdog())
4090  return false;
4091  return card.WriteRegister (kRegSDIWatchdogControlStatus, inValue, inMask, inShift);
4092 }
4093 
4094 
4095 bool CNTV2Card::KickSDIWatchdog()
4096 {
4097  if (!IsSupported(kDeviceHasSDIRelays))
4098  return false;
4099  // Write 0x01234567 into Kick2 register to begin watchdog reset, then in < 30 msec,
4100  // write 0xA5A55A5A into Kick1 register to complete the reset...
4101  const bool status (WriteRegister(kRegSDIWatchdogKick2, 0x01234567));
4102  return status && WriteRegister(kRegSDIWatchdogKick1, 0xA5A55A5A);
4103 }
4104 
4105 bool CNTV2Card::GetSDIWatchdogStatus (NTV2RelayState & outValue)
4106 {
4107  outValue = NTV2_RELAY_STATE_INVALID;
4108  if (!IsSupported(kDeviceHasSDIRelays))
4109  return false;
4110  ULWord statusBit(0);
4111  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit, kRegMaskSDIWatchdogStatus, kRegShiftSDIWatchdogStatus))
4112  return false;
4113  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4114  return true;
4115 }
4116 
4117 bool CNTV2Card::GetSDIRelayPosition (NTV2RelayState & outValue, const UWord inIndex0)
4118 {
4119  ULWord statusBit(0);
4120  outValue = NTV2_RELAY_STATE_INVALID;
4121  if (!IsSupported(kDeviceHasSDIRelays))
4122  return false;
4123  if (inIndex0 > 1)
4124  return false;
4125  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4126  inIndex0 ? kRegMaskSDIRelayPosition34 : kRegMaskSDIRelayPosition12,
4127  inIndex0 ? kRegShiftSDIRelayPosition34 : kRegShiftSDIRelayPosition12))
4128  return false;
4129  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4130  return true;
4131 }
4132 
4133 bool CNTV2Card::GetSDIRelayManualControl (NTV2RelayState & outValue, const UWord inIndex0)
4134 {
4135  ULWord statusBit(0);
4136  outValue = NTV2_RELAY_STATE_INVALID;
4137  if (!IsSupported(kDeviceHasSDIRelays))
4138  return false;
4139  if (inIndex0 > 1)
4140  return false;
4141  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4142  inIndex0 ? kRegMaskSDIRelayControl34 : kRegMaskSDIRelayControl12,
4143  inIndex0 ? kRegShiftSDIRelayControl34 : kRegShiftSDIRelayControl12))
4144  return false;
4145  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4146  return true;
4147 }
4148 
4149 bool CNTV2Card::SetSDIRelayManualControl (const NTV2RelayState inValue, const UWord inIndex0)
4150 {
4151  const ULWord statusBit ((inValue == NTV2_THROUGH_DEVICE) ? 1 : 0);
4152  if (!IsSupported(kDeviceHasSDIRelays))
4153  return false;
4154  if (inIndex0 > 1)
4155  return false;
4156  return WriteWatchdogControlBit (*this, statusBit,
4157  inIndex0 ? kRegMaskSDIRelayControl34 : kRegMaskSDIRelayControl12,
4158  inIndex0 ? kRegShiftSDIRelayControl34 : kRegShiftSDIRelayControl12);
4159 }
4160 
4161 bool CNTV2Card::GetSDIWatchdogEnable (bool & outValue, const UWord inIndex0)
4162 {
4163  ULWord statusBit(0);
4164  outValue = false;
4165  if (!IsSupported(kDeviceHasSDIRelays))
4166  return false;
4167  if (inIndex0 > 1)
4168  return false;
4169  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4170  inIndex0 ? kRegMaskSDIWatchdogEnable34 : kRegMaskSDIWatchdogEnable12,
4171  inIndex0 ? kRegShiftSDIWatchdogEnable34 : kRegShiftSDIWatchdogEnable12))
4172  return false;
4173  outValue = statusBit ? true : false;
4174  return true;
4175 }
4176 
4177 bool CNTV2Card::SetSDIWatchdogEnable (const bool inValue, const UWord inIndex0)
4178 {
4179  const ULWord statusBit ((inValue == NTV2_THROUGH_DEVICE) ? 1 : 0);
4180  if (!IsSupported(kDeviceHasSDIRelays))
4181  return false;
4182  if (inIndex0 > 1)
4183  return false;
4184  return WriteWatchdogControlBit (*this, statusBit,
4185  inIndex0 ? kRegMaskSDIWatchdogEnable34 : kRegMaskSDIWatchdogEnable12,
4186  inIndex0 ? kRegShiftSDIWatchdogEnable34 : kRegShiftSDIWatchdogEnable12);
4187 }
4188 
4189 bool CNTV2Card::GetSDIWatchdogTimeout (ULWord & outValue)
4190 {
4191  outValue = 0;
4192  if (!IsSupported(kDeviceHasSDIRelays))
4193  return false;
4194  return ReadRegister (kRegSDIWatchdogTimeout, outValue);
4195 }
4196 
4197 bool CNTV2Card::SetSDIWatchdogTimeout (const ULWord inValue)
4198 {
4199  return KickSDIWatchdog() && WriteRegister (kRegSDIWatchdogTimeout, inValue);
4200 }
4201 
4202 bool CNTV2Card::Enable4KDCRGBMode(bool enable)
4203 {
4204  return WriteRegister(kRegDC1, enable, kRegMask4KDCRGBMode, kRegShift4KDCRGBMode);
4205 }
4206 
4207 bool CNTV2Card::GetEnable4KDCRGBMode(bool & outIsEnabled)
4208 {
4209  ULWord tempVal (0);
4210  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCRGBMode, kRegShift4KDCRGBMode));
4211  outIsEnabled = static_cast <bool> (tempVal);
4212  return retVal;
4213 }
4214 
4215 bool CNTV2Card::Enable4KDCYCC444Mode(bool enable)
4216 {
4217  return WriteRegister(kRegDC1, enable, kRegMask4KDCYCC444Mode, kRegShift4KDCYCC444Mode);
4218 }
4219 
4220 bool CNTV2Card::GetEnable4KDCYCC444Mode(bool & outIsEnabled)
4221 {
4222  ULWord tempVal (0);
4223  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCYCC444Mode, kRegShift4KDCYCC444Mode));
4224  outIsEnabled = static_cast <bool> (tempVal);
4225  return retVal;
4226 }
4227 
4228 bool CNTV2Card::Enable4KDCPSFInMode(bool enable)
4229 {
4230  return WriteRegister(kRegDC1, enable, kRegMask4KDCPSFInMode, kRegShift4KDCPSFInMode);
4231 }
4232 
4233 bool CNTV2Card::GetEnable4KDCPSFInMode(bool & outIsEnabled)
4234 {
4235  ULWord tempVal (0);
4236  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCPSFInMode, kRegShift4KDCPSFInMode));
4237  outIsEnabled = static_cast <bool> (tempVal);
4238  return retVal;
4239 }
4240 
4241 bool CNTV2Card::Enable4KPSFOutMode(bool enable)
4242 {
4243  return WriteRegister(kRegDC1, enable, kRegMask4KDCPSFOutMode, kRegShift4KDCPSFOutMode);
4244 }
4245 
4246 bool CNTV2Card::GetEnable4KPSFOutMode(bool & outIsEnabled)
4247 {
4248  ULWord tempVal (0);
4249  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCPSFOutMode, kRegShift4KDCPSFOutMode));
4250  outIsEnabled = static_cast <bool> (tempVal);
4251  return retVal;
4252 }
4253 
4254 
4255 bool CNTV2Card::GetSDITRSError (const NTV2Channel inChannel)
4256 {
4257  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4258  return 0;
4259  if (IS_CHANNEL_INVALID(inChannel))
4260  return 0;
4261  ULWord value(0);
4262  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInTRSError, kRegShiftSDIInTRSError);
4263  return value ? true : false;
4264 }
4265 
4266 bool CNTV2Card::GetSDILock (const NTV2Channel inChannel)
4267 {
4268  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4269  return 0;
4270  if (IS_CHANNEL_INVALID(inChannel))
4271  return 0;
4272  ULWord value(0);
4273  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInLocked, kRegShiftSDIInLocked);
4274  return value ? true : false;
4275 }
4276 
4277 ULWord CNTV2Card::GetSDIUnlockCount (const NTV2Channel inChannel)
4278 {
4279  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4280  return 0;
4281  if (IS_CHANNEL_INVALID(inChannel))
4282  return 0;
4283  ULWord value(0);
4284  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInUnlockCount, kRegShiftSDIInUnlockCount);
4285  return value;
4286 }
4287 
4288 ULWord CNTV2Card::GetCRCErrorCountA (const NTV2Channel inChannel)
4289 {
4290  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4291  return 0;
4292  if (IS_CHANNEL_INVALID(inChannel))
4293  return 0;
4294  ULWord value(0);
4295  ReadRegister(gChannelToRXSDICRCErrorCountRegs[inChannel], value, kRegMaskSDIInCRCErrorCountA, kRegShiftSDIInCRCErrorCountA);
4296  return value;
4297 }
4298 
4299 ULWord CNTV2Card::GetCRCErrorCountB (const NTV2Channel inChannel)
4300 {
4301  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4302  return 0;
4303  if (IS_CHANNEL_INVALID(inChannel))
4304  return 0;
4305  ULWord value(0);
4306  ReadRegister(gChannelToRXSDICRCErrorCountRegs[inChannel], value, kRegMaskSDIInCRCErrorCountB, kRegShiftSDIInCRCErrorCountB);
4307  return value;
4308 }
4309 
4310 bool CNTV2Card::SetSDIInLevelBtoLevelAConversion (const UWord inInputSpigot, const bool inEnable)
4311 {
4312  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4313  return false;
4314  if (IS_INPUT_SPIGOT_INVALID (inInputSpigot))
4315  return false;
4316 
4317  ULWord regNum, mask, shift;
4318  switch (inInputSpigot)
4319  {
4320  case NTV2_CHANNEL1: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn1LevelBtoLevelA; shift = kRegShiftSDIIn1LevelBtoLevelA; break;
4321  case NTV2_CHANNEL2: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn2LevelBtoLevelA; shift = kRegShiftSDIIn2LevelBtoLevelA; break;
4322  case NTV2_CHANNEL3: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn3LevelBtoLevelA; shift = kRegShiftSDIIn3LevelBtoLevelA; break;
4323  case NTV2_CHANNEL4: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn4LevelBtoLevelA; shift = kRegShiftSDIIn4LevelBtoLevelA; break;
4324  case NTV2_CHANNEL5: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn5LevelBtoLevelA; shift = kRegShiftSDIIn5LevelBtoLevelA; break;
4325  case NTV2_CHANNEL6: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn6LevelBtoLevelA; shift = kRegShiftSDIIn6LevelBtoLevelA; break;
4326  case NTV2_CHANNEL7: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn7LevelBtoLevelA; shift = kRegShiftSDIIn7LevelBtoLevelA; break;
4327  case NTV2_CHANNEL8: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn8LevelBtoLevelA; shift = kRegShiftSDIIn8LevelBtoLevelA; break;
4328  default: return false;
4329  }
4330  return WriteRegister(regNum, inEnable, mask, shift);
4331 }
4332 
4333 bool CNTV2Card::SetSDIInLevelBtoLevelAConversion (const NTV2ChannelSet & inSDIInputs, const bool inEnable)
4334 {
4335  size_t errors(0);
4336  for (NTV2ChannelSetConstIter it(inSDIInputs.begin()); it != inSDIInputs.end(); ++it)
4337  if (!SetSDIInLevelBtoLevelAConversion(*it, inEnable))
4338  errors++;
4339  return !errors;
4340 }
4341 
4342 bool CNTV2Card::GetSDIInLevelBtoLevelAConversion (const UWord inInputSpigot, bool & outEnabled)
4343 {
4344  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4345  return false;
4346  if (IS_INPUT_SPIGOT_INVALID (inInputSpigot))
4347  return false;
4348 
4349  ULWord regNum, mask, shift;
4350  switch (inInputSpigot)
4351  {
4352  case NTV2_CHANNEL1: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn1LevelBtoLevelA; shift = kRegShiftSDIIn1LevelBtoLevelA; break;
4353  case NTV2_CHANNEL2: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn2LevelBtoLevelA; shift = kRegShiftSDIIn2LevelBtoLevelA; break;
4354  case NTV2_CHANNEL3: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn3LevelBtoLevelA; shift = kRegShiftSDIIn3LevelBtoLevelA; break;
4355  case NTV2_CHANNEL4: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn4LevelBtoLevelA; shift = kRegShiftSDIIn4LevelBtoLevelA; break;
4356  case NTV2_CHANNEL5: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn5LevelBtoLevelA; shift = kRegShiftSDIIn5LevelBtoLevelA; break;
4357  case NTV2_CHANNEL6: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn6LevelBtoLevelA; shift = kRegShiftSDIIn6LevelBtoLevelA; break;
4358  case NTV2_CHANNEL7: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn7LevelBtoLevelA; shift = kRegShiftSDIIn7LevelBtoLevelA; break;
4359  case NTV2_CHANNEL8: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn8LevelBtoLevelA; shift = kRegShiftSDIIn8LevelBtoLevelA; break;
4360  default: return false;
4361  }
4362  return CNTV2DriverInterface::ReadRegister (regNum, outEnabled, mask, shift);
4363 }
4364 
4365 bool CNTV2Card::SetSDIOutLevelAtoLevelBConversion (const UWord inOutputSpigot, const bool inEnable)
4366 {
4367  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4368  return false;
4369  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
4370  return false;
4371 
4372  return WriteRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], inEnable, kRegMaskSDIOutLevelAtoLevelB, kRegShiftSDIOutLevelAtoLevelB);
4373 }
4374 
4375 bool CNTV2Card::SetSDIOutLevelAtoLevelBConversion (const NTV2ChannelSet & inSDIOutputs, const bool inEnable)
4376 {
4377  size_t errors(0);
4378  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4379  if (!SetSDIOutLevelAtoLevelBConversion(*it, inEnable))
4380  errors++;
4381  return !errors;
4382 }
4383 
4384 bool CNTV2Card::GetSDIOutLevelAtoLevelBConversion (const UWord inOutputSpigot, bool & outEnable)
4385 {
4386  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4387  return false;
4388  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4389  return false;
4390 
4391  ULWord tempVal (0);
4392  const bool retVal (ReadRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], tempVal, kRegMaskSDIOutLevelAtoLevelB, kRegShiftSDIOutLevelAtoLevelB));
4393  outEnable = static_cast <bool> (tempVal);
4394  return retVal;
4395 }
4396 
4397 bool CNTV2Card::SetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, const bool inEnable)
4398 {
4399  if (!IsSupported(kDeviceCanDoRGBLevelAConversion))
4400  return false;
4401  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4402  return false;
4403 
4404  return WriteRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], inEnable, kRegMaskRGBLevelA, kRegShiftRGBLevelA);
4405 }
4406 
4407 bool CNTV2Card::SetSDIOutRGBLevelAConversion (const NTV2ChannelSet & inSDIOutputs, const bool inEnable)
4408 {
4409  size_t errors(0);
4410  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4411  if (!SetSDIOutRGBLevelAConversion(*it, inEnable))
4412  errors++;
4413  return !errors;
4414 }
4415 
4416 bool CNTV2Card::GetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, bool & outEnable)
4417 {
4418  if (!IsSupported(kDeviceCanDoRGBLevelAConversion))
4419  return false;
4420  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4421  return false;
4422 
4423  ULWord tempVal(0);
4424  const bool retVal(ReadRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], tempVal, kRegMaskRGBLevelA, kRegShiftRGBLevelA));
4425  outEnable = static_cast <bool> (tempVal);
4426  return retVal;
4427 }
4428 
4429 bool CNTV2Card::SetMultiFormatMode (const bool inEnable)
4430 {
4431  if (!IsSupported(kDeviceCanDoMultiFormat))
4432  return false;
4433 
4434  return WriteRegister (kRegGlobalControl2, inEnable ? 1 : 0, kRegMaskIndependentMode, kRegShiftIndependentMode);
4435 }
4436 
4437 bool CNTV2Card::GetMultiFormatMode (bool & outEnabled)
4438 {
4439  return IsSupported(kDeviceCanDoMultiFormat)
4440  ? CNTV2DriverInterface::ReadRegister (kRegGlobalControl2, outEnabled, kRegMaskIndependentMode, kRegShiftIndependentMode)
4441  : false;
4442 }
4443 
4444 bool CNTV2Card::SetRS422Parity (const NTV2Channel inChannel, const NTV2_RS422_PARITY inParity)
4445 {
4446  if (!IsSupported(kDeviceCanDoProgrammableRS422))
4447  return false; // Non-programmable RS422
4448  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4449  return false;
4450  if (inParity == NTV2_RS422_NO_PARITY)
4451  {
4452  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], 1, kRegMaskRS422ParityDisable, kRegShiftRS422ParityDisable);
4453  }
4454  else
4455  {
4456  ULWord tempVal (0);
4457  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal))
4458  return false;
4459 
4460  tempVal &= ~kRegMaskRS422ParityDisable;
4461  switch (inParity)
4462  {
4463  case NTV2_RS422_ODD_PARITY: tempVal &= ~kRegMaskRS422ParitySense; break;
4464  case NTV2_RS422_EVEN_PARITY: tempVal |= kRegMaskRS422ParitySense; break;
4465 
4466  case NTV2_RS422_PARITY_INVALID:
4467  default: return false;
4468  }
4469 
4470  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], tempVal);
4471  }
4472 }
4473 
4474 bool CNTV2Card::GetRS422Parity (const NTV2Channel inChannel, NTV2_RS422_PARITY & outParity)
4475 {
4476  outParity = NTV2_RS422_PARITY_INVALID;
4477  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4478  return false;
4479 
4480  ULWord tempVal (0);
4481  if (IsSupported(kDeviceCanDoProgrammableRS422)) // Read register only if programmable RS422
4482  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal))
4483  return false;
4484 
4485  if (tempVal & kRegMaskRS422ParityDisable)
4486  outParity = NTV2_RS422_NO_PARITY;
4487  else if (tempVal & kRegMaskRS422ParitySense)
4488  outParity = NTV2_RS422_EVEN_PARITY;
4489  else
4490  outParity = NTV2_RS422_ODD_PARITY; // Default
4491 
4492  return true;
4493 }
4494 
4495 bool CNTV2Card::SetRS422BaudRate (const NTV2Channel inChannel, const NTV2_RS422_BAUD_RATE inBaudRate)
4496 {
4497  if (!IsSupported(kDeviceCanDoProgrammableRS422))
4498  return false; // Non-programmable RS422
4499  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4500  return false; // No such serial port
4501 
4502  ULWord tempVal (0);
4503  switch (inBaudRate)
4504  {
4505  case NTV2_RS422_BAUD_RATE_38400: tempVal = 0; break;
4506  case NTV2_RS422_BAUD_RATE_19200: tempVal = 1; break;
4507  case NTV2_RS422_BAUD_RATE_9600: tempVal = 2; break;
4508  case NTV2_RS422_BAUD_RATE_INVALID:
4509  #if !defined(_DEBUG)
4510  default:
4511  #endif
4512  return false;
4513  }
4514  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], tempVal, kRegMaskRS422BaudRate, kRegShiftRS422BaudRate);
4515 }
4516 
4517 bool CNTV2Card::GetRS422BaudRate (const NTV2Channel inChannel, NTV2_RS422_BAUD_RATE & outBaudRate)
4518 {
4519  outBaudRate = NTV2_RS422_BAUD_RATE_INVALID;
4520  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4521  return false; // No such serial port
4522 
4523  ULWord tempVal (0); // Default to 38400
4524  if (IsSupported(kDeviceCanDoProgrammableRS422)) // Read register only if programmable RS422
4525  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal, kRegMaskRS422BaudRate, kRegShiftRS422BaudRate))
4526  return false; // ReadRegister failed
4527 
4528  switch (tempVal)
4529  {
4530  case 0: outBaudRate = NTV2_RS422_BAUD_RATE_38400; break;
4531  case 1: outBaudRate = NTV2_RS422_BAUD_RATE_19200; break;
4532  case 2: outBaudRate = NTV2_RS422_BAUD_RATE_9600; break;
4533  default: return false;
4534  }
4535  return true;
4536 }
4537 
4538 bool CNTV2Card::AcquireMailBoxLock()
4539 {
4540  ULWord val = 0;
4541  ReadRegister(kVRegMailBoxAcquire, val);
4542  return val;
4543 }
4544 
4545 bool CNTV2Card::ReleaseMailBoxLock()
4546 {
4547  ULWord val = 0;
4548  ReadRegister(kVRegMailBoxRelease, val);
4549  return val;
4550 }
4551 
4552 bool CNTV2Card::AbortMailBoxLock()
4553 {
4554  ULWord val = 0;
4555  ReadRegister(kVRegMailBoxAbort, val);
4556  return val;
4557 }
4558 
4559 bool CNTV2Card::GetDieTemperature (double & outTemp, const NTV2DieTempScale inTempScale)
4560 {
4561  outTemp = 0.0;
4562 
4563  // Read the temperature...
4564  ULWord rawRegValue (0);
4565  if (!ReadRegister (kRegSysmonVccIntDieTemp, rawRegValue))
4566  return false;
4567 
4568  double celsius (0);
4569  if (IsSupported(kDeviceCanDoVersalSysMon))
4570  {
4571  UWord dieTempRaw (rawRegValue & 0x0000FFFF);
4572  celsius = double (dieTempRaw) / 128.0;
4573  }
4574  else
4575  {
4576  UWord dieTempRaw ((rawRegValue & 0x0000FFFF) >> 6);
4577  celsius = (double (dieTempRaw) * 503.975 / 1024.0 - 273.15);
4578  }
4579  switch (inTempScale)
4580  {
4581  case NTV2DieTempScale_Celsius: outTemp = celsius; break;
4582  case NTV2DieTempScale_Fahrenheit: outTemp = celsius * 9.0 / 5.0 + 32.0; break;
4583  case NTV2DieTempScale_Kelvin: outTemp = celsius + 273.15; break;
4584  case NTV2DieTempScale_Rankine: outTemp = (celsius + 273.15) * 9.0 / 5.0; break;
4585  default: return false;
4586  }
4587  return true;
4588 }
4589 
4590 bool CNTV2Card::GetDieVoltage (double & outVoltage)
4591 {
4592  outVoltage = 0.0;
4593 
4594  // Read the Vcc voltage...
4595  ULWord rawRegValue (0);
4596  if (!ReadRegister (kRegSysmonVccIntDieTemp, rawRegValue))
4597  return false;
4598 
4599  const UWord coreVoltageRaw ((rawRegValue>>22) & 0x00003FF);
4600  const double coreVoltageFloat (double(coreVoltageRaw)/ 1024.0 * 3.0);
4601  outVoltage = coreVoltageFloat;
4602  return true;
4603 }
4604 
4605 bool CNTV2Card::SetWarmBootFirmwareReload(bool enable)
4606 {
4607  bool canReboot = false;
4608  CanWarmBootFPGA(canReboot);
4609  if(!canReboot)
4610  return false;
4611  return WriteRegister(kRegCPLDVersion, enable ? 1:0, BIT(8), 8);
4612 }
4613 
4614 #if defined(READREGMULTICHANGE)
4615  bool CNTV2Card::ReadRegisters (const NTV2RegNumSet & inRegisters, NTV2RegisterValueMap & outValues)
4616  {
4617  outValues.clear ();
4618  if (!IsOpen())
4619  return false; // Device not open!
4620  if (inRegisters.empty())
4621  return false; // Nothing to do!
4622 
4623  NTV2GetRegisters getRegsParams (inRegisters);
4624  if (NTV2Message(getRegsParams))
4625  {
4626  if (!getRegsParams.GetRegisterValues(outValues))
4627  return false;
4628  }
4629  else // Non-atomic user-space workaround until GETREGS implemented in driver...
4630  for (NTV2RegNumSetConstIter iter(inRegisters.begin()); iter != inRegisters.end(); ++iter)
4631  {
4632  ULWord tempVal (0);
4633  if (*iter != kRegXenaxFlashDOUT) // Prevent firmware erase/program/verify failures
4634  if (ReadRegister (*iter, tempVal))
4635  outValues[*iter] = tempVal;
4636  }
4637  return outValues.size() == inRegisters.size();
4638  }
4639 #endif // !defined(READREGMULTICHANGE)
4640 
4641 
4642 bool CNTV2Card::WriteRegisters (const NTV2RegisterWrites & inRegWrites)
4643 {
4644  if (!_boardOpened)
4645  return false; // Device not open!
4646  if (inRegWrites.empty())
4647  return true; // Nothing to do!
4648 
4649  bool result(false);
4650  NTV2SetRegisters setRegsParams(inRegWrites);
4651  //cerr << "## DEBUG: CNTV2Card::WriteRegisters: setRegsParams: " << setRegsParams << endl;
4652  result = NTV2Message(setRegsParams);
4653  if (!result)
4654  {
4655  // Non-atomic user-space workaround until SETREGS implemented in driver...
4656  const NTV2RegInfo * pRegInfos = setRegsParams.mInRegInfos;
4657  UWord * pBadNdxs = setRegsParams.mOutBadRegIndexes;
4658  for (ULWord ndx(0); ndx < setRegsParams.mInNumRegisters; ndx++)
4659  if (!WriteRegister(pRegInfos[ndx].registerNumber, pRegInfos[ndx].registerValue, pRegInfos[ndx].registerMask, pRegInfos[ndx].registerShift))
4660  pBadNdxs[setRegsParams.mOutNumFailures++] = UWord(ndx);
4661  result = true;
4662  }
4663  if (result && setRegsParams.mInNumRegisters && setRegsParams.mOutNumFailures)
4664  result = false; // fail if any writes failed
4665  if (!result) CVIDFAIL("Failed: setRegsParams: " << setRegsParams);
4666  return result;
4667 }
4668 
4669 bool CNTV2Card::BankSelectWriteRegister (const NTV2RegInfo & inBankSelect, const NTV2RegInfo & inRegInfo)
4670 {
4671  NTV2BankSelGetSetRegs bankSelGetSetMsg (inBankSelect, inRegInfo, true);
4672  //cerr << "## DEBUG: CNTV2Card::BankSelectWriteRegister: " << bankSelGetSetMsg << endl;
4673  if (!NTV2Message(bankSelGetSetMsg))
4674  // Fall back to doing 2 ops & hope nobody else clobbers the bank select register...
4675  return WriteRegister(inBankSelect.registerNumber, inBankSelect.registerValue, inBankSelect.registerMask, inBankSelect.registerShift)
4676  && WriteRegister(inRegInfo.registerNumber, inRegInfo.registerValue, inRegInfo.registerMask, inRegInfo.registerShift);
4677  return true;
4678 }
4679 
4680 bool CNTV2Card::BankSelectReadRegister (const NTV2RegInfo & inBankSelect, NTV2RegInfo & inOutRegInfo)
4681 {
4682  NTV2BankSelGetSetRegs bankSelGetSetMsg (inBankSelect, inOutRegInfo);
4683  //cerr << "## DEBUG: CNTV2Card::BankSelectReadRegister: " << bankSelGetSetMsg << endl;
4684  if (!NTV2Message(bankSelGetSetMsg))
4685  // Fall back to doing 2 ops & hope nobody else clobbers the bank select register...
4686  return WriteRegister(inBankSelect.registerNumber, inBankSelect.registerValue, inBankSelect.registerMask, inBankSelect.registerShift)
4687  && ReadRegister(inOutRegInfo.registerNumber, inOutRegInfo.registerValue, inOutRegInfo.registerMask, inOutRegInfo.registerShift);
4688  if (bankSelGetSetMsg.mInRegInfos)
4689  inOutRegInfo = bankSelGetSetMsg.GetRegInfo();
4690  return true;
4691 }
4692 
4693 bool CNTV2Card::WriteVirtualData (const ULWord inTag, const void* inVirtualData, const ULWord inVirtualDataSize)
4694 {
4695  NTV2VirtualData virtualDataMsg (inTag, inVirtualData, inVirtualDataSize, true);
4696  //cerr << "## DEBUG: CNTV2Card::WriteVirtualData: " << virtualDataMsg << endl;
4697  return NTV2Message(virtualDataMsg);
4698 }
4699 
4700 bool CNTV2Card::ReadVirtualData (const ULWord inTag, void* outVirtualData, const ULWord inVirtualDataSize)
4701 {
4702  NTV2VirtualData virtualDataMsg (inTag, outVirtualData, inVirtualDataSize, false);
4703  //cerr << "## DEBUG: CNTV2Card::ReadVirtualData: " << virtualDataMsg << endl;
4704  return NTV2Message(virtualDataMsg);
4705 }
4706 
4707 bool CNTV2Card::ReadSDIStatistics (NTV2SDIInStatistics & outStats)
4708 {
4709  outStats.Clear ();
4710  if (!_boardOpened)
4711  return false; // Device not open!
4712  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4713  return false; // Device doesn't support it!
4714  if (!NTV2Message(reinterpret_cast<NTV2_HEADER*>(&outStats)))
4715  {
4716  const ULWord numSDIInputs(GetNumSupported(kDeviceGetNumVideoInputs));
4717  NTV2RegisterReads sdiStatRegInfos;
4718  for (size_t sdi(0); sdi < numSDIInputs; sdi++)
4719  for (ULWord reg(0); reg < 6; reg++)
4720  sdiStatRegInfos.push_back(NTV2RegInfo(reg + gChannelToRXSDIStatusRegs[sdi]));
4721  sdiStatRegInfos.push_back(NTV2RegInfo(kRegRXSDIFreeRunningClockLow));
4722  sdiStatRegInfos.push_back(NTV2RegInfo(kRegRXSDIFreeRunningClockHigh));
4723  // Read the registers all at once...
4724  if (!ReadRegisters(sdiStatRegInfos))
4725  return false;
4726  // Stuff the results into outStats...
4727  for (size_t sdi(0); sdi < numSDIInputs; sdi++)
4728  {
4729  NTV2SDIInputStatus & outStat(outStats[sdi]);
4730  size_t ndx(sdi*6 + 0); // Start at kRegRXSDINStatus register
4731  NTV2_ASSERT(ndx < sdiStatRegInfos.size());
4732  NTV2RegInfo & regInfo(sdiStatRegInfos.at(ndx));
4733  NTV2_ASSERT(regInfo.registerNumber == gChannelToRXSDIStatusRegs[sdi]);
4734  outStat.mUnlockTally = regInfo.registerValue & kRegMaskSDIInUnlockCount;
4735  outStat.mLocked = regInfo.registerValue & kRegMaskSDIInLocked ? true : false;
4736  outStat.mFrameTRSError = regInfo.registerValue & kRegMaskSDIInTRSError ? true : false;
4737  outStat.mVPIDValidA = regInfo.registerValue & kRegMaskSDIInVpidValidA ? true : false;
4738  outStat.mVPIDValidB = regInfo.registerValue & kRegMaskSDIInVpidValidB ? true : false;
4739  regInfo = sdiStatRegInfos.at(ndx+1); // kRegRXSDINCRCErrorCount
4740  outStat.mCRCTallyA = regInfo.registerValue & kRegMaskSDIInCRCErrorCountA;
4741  outStat.mCRCTallyB = (regInfo.registerValue & kRegMaskSDIInCRCErrorCountB) >> kRegShiftSDIInCRCErrorCountB;
4742  // kRegRXSDINFrameCountHigh kRegRXSDINFrameCountLow
4743  //outStat.mFrameTally = (ULWord64(sdiStatRegInfos.at(ndx+2).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(ndx+1).registerValue);
4744  // kRegRXSDINFrameRefCountHigh kRegRXSDINFrameRefCountLow
4745  outStat.mFrameRefClockCount = (ULWord64(sdiStatRegInfos.at(ndx+5).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(ndx+4).registerValue);
4746  // kRegRXSDIFreeRunningClockHigh kRegRXSDIFreeRunningClockLow
4747  outStat.mGlobalClockCount = (ULWord64(sdiStatRegInfos.at(8*6+1).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(8*6+0).registerValue);
4748  } // for each SDI input
4749  }
4750  return true;
4751 }
4752 
4753 bool CNTV2Card::SetMultiRasterBypassEnable (const bool inEnable)
4754 {
4755  return HasMultiRasterWidget() && WriteRegister(kRegMROutControl, inEnable, kRegMaskMRBypass, kRegShiftMRBypass);
4756 }
4757 
4758 bool CNTV2Card::GetMultiRasterBypassEnable (bool & outEnabled)
4759 {
4760  if (!HasMultiRasterWidget())
4761  return false;
4762  NTV2ULWordVector regs; regs.push_back(0); regs.push_back(0); regs.push_back(0); regs.push_back(0);
4763  if (!ReadRegister(kRegMRQ1Control, regs.at(0))
4764  || !ReadRegister(kRegMRQ2Control, regs.at(1))
4765  || !ReadRegister(kRegMRQ3Control, regs.at(2))
4766  || !ReadRegister(kRegMRQ4Control, regs.at(3)))
4767  return false;
4768  // Any enabled quadrant means the 4K frame is being written by the hardware
4769  outEnabled = (regs.at(0) & kRegMaskMREnable)
4770  || (regs.at(1) & kRegMaskMREnable)
4771  || (regs.at(2) & kRegMaskMREnable)
4772  || (regs.at(3) & kRegMaskMREnable);
4773 // CNTV2DriverInterface::ReadRegister(kRegMROutControl, outEnabled, kRegMaskMRBypass, kRegShiftMRBypass);
4774  return true;
4775 }
4776 
4777 bool CNTV2Card::IsMultiRasterWidgetChannel (const NTV2Channel inChannel)
4778 {
4779  return HasMultiRasterWidget() && inChannel == NTV2Channel(GetNumSupported(kDeviceGetNumVideoChannels));
4780 }
4781 
4782 
4784 
4785 #ifdef MSWindows
4786 #pragma warning(default: 4800)
4787 #endif
kRegMaskSDIIn43GbpsMode
@ kRegMaskSDIIn43GbpsMode
Definition: ntv2publicinterface.h:2000
kRegShiftInput1Geometry
@ kRegShiftInput1Geometry
Definition: ntv2publicinterface.h:2505
kRegSDIInput3GStatus
@ kRegSDIInput3GStatus
Definition: ntv2publicinterface.h:373
kRegMaskSDIIn33GbpsSMPTELevelBMode
@ kRegMaskSDIIn33GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:1994
kRegShiftSDIIn612GbpsMode
@ kRegShiftSDIIn612GbpsMode
Definition: ntv2publicinterface.h:3086
CNTV2Card::SetVANCMode
virtual bool SetVANCMode(const NTV2VANCMode inVancMode, const NTV2Channel inChannel=NTV2_CHANNEL1)
Sets the VANC mode for the given FrameStore.
Definition: ntv2register.cpp:2704
kRegShiftSDIIn1LevelBtoLevelA
@ kRegShiftSDIIn1LevelBtoLevelA
Definition: ntv2publicinterface.h:3042
kRegShiftQuadTsiEnable
@ kRegShiftQuadTsiEnable
Definition: ntv2publicinterface.h:2338
kRegMask4KDCYCC444Mode
@ kRegMask4KDCYCC444Mode
Definition: ntv2publicinterface.h:2106
kRegShiftSDI4Transmit
@ kRegShiftSDI4Transmit
Definition: ntv2publicinterface.h:3153
NTV2_REFERENCE_HDMI_INPUT2
@ NTV2_REFERENCE_HDMI_INPUT2
Specifies the HDMI In 2 connector.
Definition: ntv2enums.h:1461
gSDIOutToRP188Input
static const ULWord gSDIOutToRP188Input[]
Definition: ntv2register.cpp:2643
kRegGlobalControlCh3
@ kRegGlobalControlCh3
Definition: ntv2publicinterface.h:546
kDeviceGetNumVideoInputs
@ kDeviceGetNumVideoInputs
The number of SDI video inputs on the device.
Definition: ntv2devicefeatures.h:212
CNTV2Card::SetSDIInLevelBtoLevelAConversion
virtual bool SetSDIInLevelBtoLevelAConversion(const NTV2ChannelSet &inSDIInputs, const bool inEnable)
Enables or disables 3G level B to 3G level A conversion at the SDI input(s).
Definition: ntv2register.cpp:4333
kRegSDIOut4Control
@ kRegSDIOut4Control
Definition: ntv2publicinterface.h:308
NTV2_FORMAT_3840x2160p_6000
@ NTV2_FORMAT_3840x2160p_6000
Definition: ntv2enums.h:646
kRegGlobalControlCh5
@ kRegGlobalControlCh5
Definition: ntv2publicinterface.h:548
BIT_3
#define BIT_3
Definition: ajatypes.h:577
kRegSDIWatchdogTimeout
@ kRegSDIWatchdogTimeout
Definition: ntv2publicinterface.h:458
kVRegProgressivePicture
@ kVRegProgressivePicture
Definition: ntv2virtualregisters.h:223
NTV2_FORMAT_4096x2160psf_2500
@ NTV2_FORMAT_4096x2160psf_2500
Definition: ntv2enums.h:654
kK2RegMaskSDIOutDS2Audio_Bit0
@ kK2RegMaskSDIOutDS2Audio_Bit0
Definition: ntv2publicinterface.h:1686
kRegMaskInput1Geometry
@ kRegMaskInput1Geometry
Definition: ntv2publicinterface.h:1413
CNTV2Card::SetMixerFGMatteEnabled
virtual bool SetMixerFGMatteEnabled(const UWord inWhichMixer, const bool inIsEnabled)
Answers if the given mixer/keyer's foreground matte is enabled or not.
Definition: ntv2register.cpp:3046
kRegMaskVidProcLimiting
@ kRegMaskVidProcLimiting
Definition: ntv2publicinterface.h:1342
kDeviceHasBiDirectionalSDI
@ kDeviceHasBiDirectionalSDI
True if device SDI connectors are bi-directional.
Definition: ntv2devicefeatures.h:93
DEVICE_ID_KONALHIDVI
@ DEVICE_ID_KONALHIDVI
See KONA LHi.
Definition: ntv2enums.h:77
kRegCh2OutputFrame
@ kRegCh2OutputFrame
Definition: ntv2publicinterface.h:127
kRegCh7Control
@ kRegCh7Control
Definition: ntv2publicinterface.h:563
kRegMaskLTCOnRefInSelect
@ kRegMaskLTCOnRefInSelect
Definition: ntv2publicinterface.h:1545
CNTV2Card::GetDieTemperature
virtual bool GetDieTemperature(double &outTemp, const NTV2DieTempScale inTempScale=NTV2DieTempScale_Celsius)
Reads the current die temperature of the device.
Definition: ntv2register.cpp:4559
NTV2_FORMAT_625_5000
@ NTV2_FORMAT_625_5000
Definition: ntv2enums.h:574
kRegCh8Control
@ kRegCh8Control
Definition: ntv2publicinterface.h:568
NTV2_FORMAT_4x1920x1080p_6000
@ NTV2_FORMAT_4x1920x1080p_6000
Definition: ntv2enums.h:610
gChannelToSDIInputProgressiveMask
static const ULWord gChannelToSDIInputProgressiveMask[]
Definition: ntv2register.cpp:170
SSC_GET_FIRMWARE_PROGRESS_STRUCT::programTotalSize
ULWord programTotalSize
Definition: ntv2publicinterface.h:5068
CNTV2Card::SetMultiFormatMode
virtual bool SetMultiFormatMode(const bool inEnable)
Enables or disables multi-format (per channel) device operation. If enabled, each device channel can ...
Definition: ntv2register.cpp:4429
NTV2_INPUTSOURCE_SDI4
@ NTV2_INPUTSOURCE_SDI4
Identifies the 4th SDI video input.
Definition: ntv2enums.h:1266
kK2RegMaskXena2BgVidProcInputControl
@ kK2RegMaskXena2BgVidProcInputControl
Definition: ntv2publicinterface.h:1956
kRegRS4222Control
@ kRegRS4222Control
Definition: ntv2publicinterface.h:387
CNTV2Card::GetSDIInput3GPresent
virtual bool GetSDIInput3GPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3666
NTV2_FG_4x2048x1080
@ NTV2_FG_4x2048x1080
4096x2160, for 4K, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:363
NTV2VANCModeFromBools
#define NTV2VANCModeFromBools(_tall_, _taller_)
Definition: ntv2enums.h:3788
kRegRXSDI3CRCErrorCount
@ kRegRXSDI3CRCErrorCount
Definition: ntv2publicinterface.h:739
kRegFlatMatteValue
@ kRegFlatMatteValue
Definition: ntv2publicinterface.h:133
kRegShiftInputStatusFPS
@ kRegShiftInputStatusFPS
Definition: ntv2publicinterface.h:2715
NTV2_FORMAT_3840x2160psf_2500
@ NTV2_FORMAT_3840x2160psf_2500
Definition: ntv2enums.h:636
NTV2_FORMAT_1080psf_2398
@ NTV2_FORMAT_1080psf_2398
Definition: ntv2enums.h:546
kRegMask4KDCPSFInMode
@ kRegMask4KDCPSFInMode
Definition: ntv2publicinterface.h:2107
CNTV2Card::SetPCIAccessFrame
virtual bool SetPCIAccessFrame(const NTV2Channel inChannel, const ULWord inValue, const bool inWaitForVBI=(!(0)))
Definition: ntv2register.cpp:2228
NTV2SDIInputStatus::mVPIDValidB
bool mVPIDValidB
If true, at least one valid SMPTE 352 packet was received over the last four VBI periods.
Definition: ntv2publicinterface.h:7118
CNTV2Card::GetSDIRelayPosition
virtual bool GetSDIRelayPosition(NTV2RelayState &outValue, const UWord inIndex0)
Answers if the bypass relays between connectors 1/2 or 3/4 are currently in bypass or routing the sig...
Definition: ntv2register.cpp:4117
kDeviceGetNumMixers
@ kDeviceGetNumMixers
The number of mixer/keyer widgets on the device.
Definition: ntv2devicefeatures.h:207
CNTV2Card::SetFrameBufferSize
virtual bool SetFrameBufferSize(const NTV2Framesize inSize)
Sets the device's intrinsic frame buffer size.
Definition: ntv2register.cpp:1756
NTV2DeviceGetVideoFormatFromState_Ex2
bool NTV2DeviceGetVideoFormatFromState_Ex2(NTV2VideoFormat *pOutValue, const NTV2FrameRate inFrameRate, const NTV2FrameGeometry inFrameGeometry, const NTV2Standard inStandard, const ULWord inIsSMPTE372Enabled, const bool inIsProgressivePicture, const bool inIsSquareDivision)
Definition: ntv2devicefeatures.cpp:686
LWord
int32_t LWord
Definition: ajatypes.h:255
CNTV2Card::GetSDIOut12GEnable
virtual bool GetSDIOut12GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3984
kRegShiftSDIOutLevelAtoLevelB
@ kRegShiftSDIOutLevelAtoLevelB
Definition: ntv2publicinterface.h:2761
kDeviceGetNumFrameStores
@ kDeviceGetNumFrameStores
The number of FrameStores on the device.
Definition: ntv2devicefeatures.h:199
NTV2_FORMAT_4096x2160p_2400
@ NTV2_FORMAT_4096x2160p_2400
Definition: ntv2enums.h:656
kRegShift4KDCPSFOutMode
@ kRegShift4KDCPSFOutMode
Definition: ntv2publicinterface.h:3170
kK2RegShiftSDI1Out_2Kx1080Mode
@ kK2RegShiftSDI1Out_2Kx1080Mode
Definition: ntv2publicinterface.h:2754
INSTP
#define INSTP(_p_)
Definition: ntv2register.cpp:25
kRegLTCAnalogBits0_31
@ kRegLTCAnalogBits0_31
Definition: ntv2publicinterface.h:238
NTV2_FBF_NUMFRAMEBUFFERFORMATS
@ NTV2_FBF_NUMFRAMEBUFFERFORMATS
Definition: ntv2enums.h:250
NTV2SDIInStatistics::Clear
void Clear(void)
Resets the struct to its initialized state.
Definition: ntv2publicinterface.cpp:2508
NTV2SDIInputStatus::mGlobalClockCount
ULWord64 mGlobalClockCount
This count is incremented on each 148.xx reference clock.
Definition: ntv2publicinterface.h:7112
NTV2_IS_VANCMODE_TALLER
#define NTV2_IS_VANCMODE_TALLER(__v__)
Definition: ntv2enums.h:3785
NTV2RegNumSetConstIter
ULWordSetConstIter NTV2RegNumSetConstIter
A const iterator that iterates over a set of distinct NTV2RegisterNumbers.
Definition: ntv2publicinterface.h:7658
CNTV2Card::GetRS422Parity
virtual bool GetRS422Parity(const NTV2Channel inSerialPort, NTV2_RS422_PARITY &outParity)
Answers with the current parity control for the specified RS422 serial port.
Definition: ntv2register.cpp:4474
NTV2_FORMAT_2K_1498
@ NTV2_FORMAT_2K_1498
Definition: ntv2enums.h:581
NTV2RegisterValueMap
std::map< ULWord, ULWord > NTV2RegisterValueMap
A mapping of distinct NTV2RegisterNumbers to their corresponding ULWord values.
Definition: ntv2publicinterface.h:7675
NTV2_FORMAT_720p_5000
@ NTV2_FORMAT_720p_5000
Definition: ntv2enums.h:557
NTV2_NUM_STANDARDS
@ NTV2_NUM_STANDARDS
Definition: ntv2enums.h:177
NTV2_RELAY_STATE_INVALID
@ NTV2_RELAY_STATE_INVALID
Definition: ntv2enums.h:3919
kRegMaskChannelDisable
@ kRegMaskChannelDisable
Definition: ntv2publicinterface.h:1309
kRegRXSDI8Status
@ kRegRXSDI8Status
Definition: ntv2publicinterface.h:783
kRegOutputTimingControlch6
@ kRegOutputTimingControlch6
Definition: ntv2publicinterface.h:672
kRegShiftRS422ParityDisable
@ kRegShiftRS422ParityDisable
Definition: ntv2publicinterface.h:2589
kRegShiftInputStatusStd
@ kRegShiftInputStatusStd
Definition: ntv2publicinterface.h:2713
CNTV2DriverInterface::ReadRegisters
virtual bool ReadRegisters(NTV2RegisterReads &inOutValues)
Reads the register(s) specified by the given NTV2RegInfo sequence.
Definition: ntv2driverinterface.cpp:444
CNTV2Card::GetLTCInputPresent
virtual bool GetLTCInputPresent(bool &outIsPresent, const UWord inLTCInputNdx=0)
Answers whether or not a valid analog LTC signal is being applied to the device's analog LTC input co...
Definition: ntv2register.cpp:3732
NTV2FrameGeometryToString
std::string NTV2FrameGeometryToString(const NTV2FrameGeometry inValue, const bool inForRetailDisplay=false)
defined(NTV2_DEPRECATE_17_6)
Definition: ntv2utils.cpp:7208
NTV2_CHANNEL8
@ NTV2_CHANNEL8
Specifies channel or FrameStore 8 (or the 8th item).
Definition: ntv2enums.h:1355
DEVICE_ID_KONAHDMI
@ DEVICE_ID_KONAHDMI
See KONA HDMI.
Definition: ntv2enums.h:66
CNTV2Card::SetStandard
virtual bool SetStandard(NTV2Standard inValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:807
kRegRP188InOut3DBB
@ kRegRP188InOut3DBB
Definition: ntv2publicinterface.h:409
NTV2_INPUTSOURCE_SDI6
@ NTV2_INPUTSOURCE_SDI6
Identifies the 6th SDI video input.
Definition: ntv2enums.h:1268
NTV2_FORMAT_2K_2400
@ NTV2_FORMAT_2K_2400
Definition: ntv2enums.h:584
NTV2_RP188_INVALID
@ NTV2_RP188_INVALID
Definition: ntv2enums.h:2089
NTV2_IS_VALID_NTV2FrameGeometry
#define NTV2_IS_VALID_NTV2FrameGeometry(__s__)
Definition: ntv2enums.h:374
kRegShiftAnalogCompositeLocked
@ kRegShiftAnalogCompositeLocked
Definition: ntv2publicinterface.h:2670
kRegShiftPCRReferenceEnable
@ kRegShiftPCRReferenceEnable
Definition: ntv2publicinterface.h:2347
NTV2_STANDARD_2Kx1080p
@ NTV2_STANDARD_2Kx1080p
Identifies SMPTE HD 2K1080p.
Definition: ntv2enums.h:167
NTV2_REFERENCE_SFP1_PTP
@ NTV2_REFERENCE_SFP1_PTP
Specifies the PTP source on SFP 1.
Definition: ntv2enums.h:1457
NTV2_FORMAT_4x4096x2160p_4800
@ NTV2_FORMAT_4x4096x2160p_4800
Definition: ntv2enums.h:705
CNTV2Card::GetRegisterWriteMode
virtual bool GetRegisterWriteMode(NTV2RegisterWriteMode &outValue, const NTV2Channel inFrameStore=NTV2_CHANNEL1)
Answers with the FrameStore's current NTV2RegisterWriteMode setting, which determines when CNTV2Card:...
Definition: ntv2register.cpp:2534
kRegMaskHDMIInV2VideoStd
@ kRegMaskHDMIInV2VideoStd
Definition: ntv2publicinterface.h:1619
kRegMixer1Coefficient
@ kRegMixer1Coefficient
Definition: ntv2publicinterface.h:131
gChannelToOutputTimingCtrlRegNum
static const ULWord gChannelToOutputTimingCtrlRegNum[]
Definition: ntv2register.cpp:88
kRegMaskLED
@ kRegMaskLED
Definition: ntv2publicinterface.h:1242
NTV2SDIInputStatus::mVPIDValidA
bool mVPIDValidA
If true, at least one valid SMPTE 352 packet was received over the last four VBI periods.
Definition: ntv2publicinterface.h:7117
CNTV2Card::SetWarmBootFirmwareReload
virtual bool SetWarmBootFirmwareReload(bool enable)
Definition: ntv2register.cpp:4605
CNTV2Card::SetSDIOut2Kx1080Enable
virtual bool SetSDIOut2Kx1080Enable(const NTV2Channel inChannel, const bool inIsEnabled)
Definition: ntv2register.cpp:3906
NTV2MIXERMODE_INVALID
@ NTV2MIXERMODE_INVALID
Invalid/uninitialized.
Definition: ntv2enums.h:1786
kRegShiftDualLinkInput
@ kRegShiftDualLinkInput
Definition: ntv2publicinterface.h:2337
CNTV2Card::SetQuadFrameEnable
virtual bool SetQuadFrameEnable(const bool inValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Enables or disables quad-frame mode on the device.
Definition: ntv2register.cpp:1092
kRegShiftQuality2
@ kRegShiftQuality2
Definition: ntv2publicinterface.h:2415
NTV2_CHANNEL2
@ NTV2_CHANNEL2
Specifies channel or FrameStore 2 (or the 2nd item).
Definition: ntv2enums.h:1349
NTV2_VANCDATA_NORMAL
@ NTV2_VANCDATA_NORMAL
Definition: ntv2enums.h:3793
NTV2_FORMAT_4x4096x2160p_2398
@ NTV2_FORMAT_4x4096x2160p_2398
Definition: ntv2enums.h:699
CNTV2Card::GetForce64
virtual bool GetForce64(ULWord *force64)
Definition: ntv2register.cpp:3252
gChannelToSDIOutControlRegNum
static const ULWord gChannelToSDIOutControlRegNum[]
Definition: ntv2register.cpp:71
kRegRP188InOut2Bits0_31
@ kRegRP188InOut2Bits0_31
Definition: ntv2publicinterface.h:186
CNTV2Card::SetSDIOut3GEnable
virtual bool SetSDIOut3GEnable(const NTV2Channel inChannel, const bool inEnable)
Definition: ntv2register.cpp:3920
NTV2_FORMAT_525_5994
@ NTV2_FORMAT_525_5994
Definition: ntv2enums.h:573
kRegCh6OutputFrame
@ kRegCh6OutputFrame
Definition: ntv2publicinterface.h:559
kRegMaskSDIIn23GbpsMode
@ kRegMaskSDIIn23GbpsMode
Definition: ntv2publicinterface.h:1982
CNTV2Card::KickSDIWatchdog
virtual bool KickSDIWatchdog(void)
Restarts the countdown timer to prevent the watchdog timer from timing out.
Definition: ntv2register.cpp:4095
CNTV2Card::SetVideoFormat
virtual bool SetVideoFormat(const NTV2VideoFormat inVideoFormat, const bool inIsAJARetail=(!(0)), const bool inKeepVancSettings=(0), const NTV2Channel inChannel=NTV2_CHANNEL1)
Configures the AJA device to handle a specific video format.
Definition: ntv2register.cpp:204
CNTV2KonaFlashProgram::SetMBReset
bool SetMBReset()
Definition: ntv2konaflashprogram.cpp:140
kRegMRQ3Control
@ kRegMRQ3Control
Definition: ntv2publicinterface.h:1052
kRegMaskQuality2
@ kRegMaskQuality2
Definition: ntv2publicinterface.h:1323
kRegDC1
@ kRegDC1
Definition: ntv2publicinterface.h:516
kRegMaskInput2FrameRate
@ kRegMaskInput2FrameRate
Definition: ntv2publicinterface.h:1415
NTV2WidgetType_SDIIn12G
@ NTV2WidgetType_SDIIn12G
Definition: ntv2enums.h:3066
NTV2InputXptIDSet
std::set< NTV2InputXptID > NTV2InputXptIDSet
A collection of distinct NTV2InputXptID values.
Definition: ntv2signalrouter.h:26
CNTV2Card::Set4kSquaresEnable
virtual bool Set4kSquaresEnable(const bool inIsEnabled, const NTV2Channel inChannel)
Enables or disables SMPTE 425 "2K quadrants" mode for the given FrameStore bank on the device....
Definition: ntv2register.cpp:1238
kRegShiftRP188ModeCh1
@ kRegShiftRP188ModeCh1
Definition: ntv2publicinterface.h:2341
kRegRP188InOut1Bits0_31
@ kRegRP188InOut1Bits0_31
Definition: ntv2publicinterface.h:151
kNTV2EnumsID_VideoFormat
@ kNTV2EnumsID_VideoFormat
Identifies the NTV2VideoFormat enumerated type.
Definition: ntv2devicefeatures.h:246
kRegRXSDI4Status
@ kRegRXSDI4Status
Definition: ntv2publicinterface.h:747
NTV2_FG_1920x1114
@ NTV2_FG_1920x1114
1920x1080, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:349
kRegRP188InOut7Bits32_63
@ kRegRP188InOut7Bits32_63
Definition: ntv2publicinterface.h:602
CNTV2Card::SetSDIWatchdogEnable
virtual bool SetSDIWatchdogEnable(const bool inEnable, const UWord inIndex0)
Sets the connector pair relays to be under watchdog timer control or manual control.
Definition: ntv2register.cpp:4177
CNTV2Card::SetFrameBufferQuarterSizeMode
virtual bool SetFrameBufferQuarterSizeMode(NTV2Channel inChannel, NTV2QuarterSizeExpandMode inValue)
Definition: ntv2register.cpp:1957
gChannelToSDIInputRateShift
static const ULWord gChannelToSDIInputRateShift[]
Definition: ntv2register.cpp:156
CNTV2Card::GetSDIOut3GEnable
virtual bool GetSDIOut3GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3927
CNTV2Card::GetRegisterBaseAddress
virtual bool GetRegisterBaseAddress(ULWord regNumber, ULWord **pRegAddress)
Definition: ntv2register.cpp:3183
ntv2devicefeatures.h
Declares device capability functions.
NTV2_FG_720x576
@ NTV2_FG_720x576
720x576, for PAL 625i, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:348
CNTV2Card::GetVideoHOffset
virtual bool GetVideoHOffset(int &outHOffset, const UWord inOutputSpigot=0)
Answers with the current horizontal timing offset, in pixels, for the given SDI output connector.
Definition: ntv2register.cpp:702
NTV2_FG_720x508
@ NTV2_FG_720x508
720x486, for NTSC 525i, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:351
CNTV2Card::AcquireMailBoxLock
virtual bool AcquireMailBoxLock(void)
Definition: ntv2register.cpp:4538
CNTV2Card::SetRP188Mode
virtual bool SetRP188Mode(const NTV2Channel inChannel, const NTV2_RP188Mode inMode)
Sets the current RP188 mode – NTV2_RP188_INPUT or NTV2_RP188_OUTPUT – for the given channel.
Definition: ntv2register.cpp:2555
K2_NOMINAL_H
#define K2_NOMINAL_H
Definition: ntv2register.cpp:44
kK2RegShiftXena2VidProcMode
@ kK2RegShiftXena2VidProcMode
Definition: ntv2publicinterface.h:3020
kRegCh5InputFrame
@ kRegCh5InputFrame
Definition: ntv2publicinterface.h:555
NTV2FormatDescriptor
Describes a video frame for a given video standard or format and pixel format, including the total nu...
Definition: ntv2formatdescriptor.h:41
kDeviceHasXptConnectROM
@ kDeviceHasXptConnectROM
True if device has a crosspoint connection ROM (New in SDK 17.0)
Definition: ntv2devicefeatures.h:148
kRegMask425FB56
@ kRegMask425FB56
Definition: ntv2publicinterface.h:1274
NTV2DeviceGetNumberFrameBuffers
ULWord NTV2DeviceGetNumberFrameBuffers(NTV2DeviceID id, NTV2FrameGeometry fg, NTV2FrameBufferFormat fbf)
Definition: ntv2devicefeatures.cpp:497
kK2RegMaskXena2VidProcMode
@ kK2RegMaskXena2VidProcMode
Definition: ntv2publicinterface.h:1957
NTV2_FORMAT_4096x2160p_2500
@ NTV2_FORMAT_4096x2160p_2500
Definition: ntv2enums.h:657
kRegShiftSDIIn16GbpsMode
@ kRegShiftSDIIn16GbpsMode
Definition: ntv2publicinterface.h:3045
CNTV2Card::GetPCIAccessFrame
virtual bool GetPCIAccessFrame(const NTV2Channel inChannel, ULWord &outValue)
Definition: ntv2register.cpp:2238
NTV2_FRAMERATE_1500
@ NTV2_FRAMERATE_1500
15 frames per second
Definition: ntv2enums.h:422
kRegShiftSDIRelayPosition34
@ kRegShiftSDIRelayPosition34
Definition: ntv2publicinterface.h:3161
NTV2_FRAMERATE_6000
@ NTV2_FRAMERATE_6000
60 frames per second
Definition: ntv2enums.h:409
kRegMaskSDIIn86GbpsMode
@ kRegMaskSDIIn86GbpsMode
Definition: ntv2publicinterface.h:2035
kRegAnalogOutControl
@ kRegAnalogOutControl
Definition: ntv2publicinterface.h:261
CNTV2Card::GetMixerSyncStatus
virtual bool GetMixerSyncStatus(const UWord inWhichMixer, bool &outIsSyncOK)
Returns the current sync state of the given mixer/keyer.
Definition: ntv2register.cpp:3026
kRegOutputTimingControlch7
@ kRegOutputTimingControlch7
Definition: ntv2publicinterface.h:673
NTV2_INPUTSOURCE_SDI7
@ NTV2_INPUTSOURCE_SDI7
Identifies the 7th SDI video input.
Definition: ntv2enums.h:1269
kDeviceCanDoSDIErrorChecks
@ kDeviceCanDoSDIErrorChecks
True if device can perform SDI error checking.
Definition: ntv2devicefeatures.h:85
kRegShiftSDI1Transmit
@ kRegShiftSDI1Transmit
Definition: ntv2publicinterface.h:3150
NTV2DieTempScale_Kelvin
@ NTV2DieTempScale_Kelvin
Definition: ntv2enums.h:4192
kRegInput78Status
@ kRegInput78Status
Definition: ntv2publicinterface.h:644
GetNTV2FrameGeometryFromVideoFormat
NTV2FrameGeometry GetNTV2FrameGeometryFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:2548
NTV2_REFERENCE_SFP2_PCR
@ NTV2_REFERENCE_SFP2_PCR
Specifies the PCR source on SFP 2.
Definition: ntv2enums.h:1460
CNTV2Card::GetMixerBGInputControl
virtual bool GetMixerBGInputControl(const UWord inWhichMixer, NTV2MixerKeyerInputControl &outInputControl)
Returns the current background input control value for the given mixer/keyer.
Definition: ntv2register.cpp:2970
NTV2_FORMAT_525psf_2997
@ NTV2_FORMAT_525psf_2997
Definition: ntv2enums.h:577
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They're also commonly use...
Definition: ntv2enums.h:1346
NTV2_FG_4x4096x2160
@ NTV2_FG_4x4096x2160
8192x4320, for 8K, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:367
kRegShiftRP188ModeCh4
@ kRegShiftRP188ModeCh4
Definition: ntv2publicinterface.h:2370
kRegShiftSDIOut12GbpsMode
@ kRegShiftSDIOut12GbpsMode
Definition: ntv2publicinterface.h:2759
GetQuarterSizedGeometry
NTV2FrameGeometry GetQuarterSizedGeometry(const NTV2FrameGeometry inGeometry)
Definition: ntv2utils.cpp:2219
CNTV2Card::IsProgressiveStandard
virtual bool IsProgressiveStandard(bool &outIsProgressive, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:855
NTV2_FORMAT_4x2048x1080p_4795
@ NTV2_FORMAT_4x2048x1080p_4795
Definition: ntv2enums.h:614
NTV2DeviceCanDo25GIP
bool NTV2DeviceCanDo25GIP(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:575
CNTV2Card::GetDieVoltage
virtual bool GetDieVoltage(double &outVoltage)
Reads the current "Vcc" voltage of the device.
Definition: ntv2register.cpp:4590
kRegMaskSDIIn612GbpsMode
@ kRegMaskSDIIn612GbpsMode
Definition: ntv2publicinterface.h:2022
NTV2_REFERENCE_INPUT7
@ NTV2_REFERENCE_INPUT7
Specifies the SDI In 7 connector.
Definition: ntv2enums.h:1455
CNTV2Card::GetStandard
virtual bool GetStandard(NTV2Standard &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:828
NTV2_IS_2K1080_STANDARD
#define NTV2_IS_2K1080_STANDARD(__s__)
Definition: ntv2enums.h:203
CNTV2Card::GetSDIOutputStandard
virtual bool GetSDIOutputStandard(const UWord inOutputSpigot, NTV2Standard &outValue)
Answers with the current video standard of the given SDI output spigot.
Definition: ntv2register.cpp:3322
kRegShiftInput2FrameRate
@ kRegShiftInput2FrameRate
Definition: ntv2publicinterface.h:2507
NTV2_FORMAT_4096x2160psf_2398
@ NTV2_FORMAT_4096x2160psf_2398
Definition: ntv2enums.h:652
CNTV2Card::SetFrameBufferOrientation
virtual bool SetFrameBufferOrientation(const NTV2Channel inChannel, const NTV2FBOrientation inValue)
Sets the frame buffer orientation for the given NTV2Channel.
Definition: ntv2register.cpp:2031
kVRegFlashState
@ kVRegFlashState
Definition: ntv2virtualregisters.h:303
YCbCr10BitPixel::cb
UWord cb
Definition: ntv2videodefines.h:202
kRegShiftLTCOnRefInSelect
@ kRegShiftLTCOnRefInSelect
Definition: ntv2publicinterface.h:2634
NTV2_STANDARD_INVALID
@ NTV2_STANDARD_INVALID
Definition: ntv2enums.h:179
NTV2_ASSERT
#define NTV2_ASSERT(_expr_)
Definition: ajatypes.h:509
CNTV2KonaFlashProgram::Program
std::string Program(bool fullVerify=(0))
Definition: ntv2konaflashprogram.cpp:538
kRegMaskSDIIn43GbpsSMPTELevelBMode
@ kRegMaskSDIIn43GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2001
kFS1RefMaskLTCOnRefInSelect
@ kFS1RefMaskLTCOnRefInSelect
Definition: ntv2publicinterface.h:1544
NTV2_STANDARD_1080
@ NTV2_STANDARD_1080
Identifies SMPTE HD 1080i or 1080psf.
Definition: ntv2enums.h:161
NTV2_STANDARD_3840x2160p
@ NTV2_STANDARD_3840x2160p
Identifies Ultra-High-Definition (UHD)
Definition: ntv2enums.h:169
kRegMaskSDIIn53GbpsSMPTELevelBMode
@ kRegMaskSDIIn53GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2010
kRegShiftSDIIn312GbpsMode
@ kRegShiftSDIIn312GbpsMode
Definition: ntv2publicinterface.h:3063
CNTV2Card::SetSmpte372
virtual bool SetSmpte372(ULWord inValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Enables or disables the device's SMPTE-372 (dual-link) mode (used for older 3G-levelB-capable devices...
Definition: ntv2register.cpp:1043
NTV2_FRAMERATE_2997
@ NTV2_FRAMERATE_2997
Fractional rate of 30,000 frames per 1,001 seconds.
Definition: ntv2enums.h:413
kRegSDIWatchdogKick1
@ kRegSDIWatchdogKick1
Definition: ntv2publicinterface.h:459
NTV2DeviceGetFrameBufferSize
ULWord NTV2DeviceGetFrameBufferSize(NTV2DeviceID id, NTV2FrameGeometry fg, NTV2FrameBufferFormat fbf)
Definition: ntv2devicefeatures.cpp:325
kRegCh3PCIAccessFrame
@ kRegCh3PCIAccessFrame
Definition: ntv2publicinterface.h:430
GetNTV2FrameRateFromVideoFormat
NTV2FrameRate GetNTV2FrameRateFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:3534
NTV2_VIDEOLIMITING_LEGALSDI
@ NTV2_VIDEOLIMITING_LEGALSDI
Identifies the "Legal SDI" mode (Ymax=0x3AC, Cmax=0x3C0)
Definition: ntv2enums.h:3758
SSC_GET_FIRMWARE_PROGRESS_STRUCT::programProgress
ULWord programProgress
Definition: ntv2publicinterface.h:5069
kRegShiftFrameRate
@ kRegShiftFrameRate
Definition: ntv2publicinterface.h:2328
CNTV2Card::SetMixerCoefficient
virtual bool SetMixerCoefficient(const UWord inWhichMixer, const ULWord inMixCoefficient)
Sets the current mix coefficient of the given mixer/keyer.
Definition: ntv2register.cpp:3008
kRegMixer4Coefficient
@ kRegMixer4Coefficient
Definition: ntv2publicinterface.h:681
CNTV2Card::GetEnable4KPSFOutMode
virtual bool GetEnable4KPSFOutMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4246
CNTV2Card::GetVideoVOffset
virtual bool GetVideoVOffset(int &outVOffset, const UWord inOutputSpigot=0)
Answers with the current vertical timing offset, in lines, for the given SDI output connector.
Definition: ntv2register.cpp:750
kRegRP188InOut6Bits0_31
@ kRegRP188InOut6Bits0_31
Definition: ntv2publicinterface.h:591
NTV2_STANDARD_625
@ NTV2_STANDARD_625
Identifies SMPTE SD 625i.
Definition: ntv2enums.h:164
CNTV2Card::SetMixerBGInputControl
virtual bool SetMixerBGInputControl(const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
Sets the background input control value for the given mixer/keyer.
Definition: ntv2register.cpp:2961
CNTV2Card::GetSDI1OutHTiming
virtual bool GetSDI1OutHTiming(ULWord *value)
Definition: ntv2register.cpp:3397
kRegShiftForce64
@ kRegShiftForce64
Definition: ntv2publicinterface.h:2527
NTV2_FORMAT_1080psf_2K_2398
@ NTV2_FORMAT_1080psf_2K_2398
Definition: ntv2enums.h:555
kRegShiftSDIOut6GbpsMode
@ kRegShiftSDIOut6GbpsMode
Definition: ntv2publicinterface.h:2758
CNTV2Card::IsXilinxProgrammed
virtual bool IsXilinxProgrammed()
Definition: ntv2register.cpp:2308
kRegShiftRP188ModeCh2
@ kRegShiftRP188ModeCh2
Definition: ntv2publicinterface.h:2342
CNTV2Card::SetRP188Data
virtual bool SetRP188Data(const NTV2Channel inSDIOutput, const NTV2_RP188 &inRP188Data)
Writes the raw RP188 data into the DBB/Low/Hi registers for the given SDI output. These values are la...
Definition: ntv2register.cpp:2585
CNTV2SignalRouter::GetWidgetOutputs
static bool GetWidgetOutputs(const NTV2WidgetID inWidgetID, NTV2OutputXptIDSet &outOutputs)
Returns the output crosspoints known to be "owned" by the given widget.
Definition: ntv2signalrouter.cpp:494
CNTV2Card::SetFrameRate
virtual bool SetFrameRate(NTV2FrameRate inNewValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Sets the AJA device's frame rate.
Definition: ntv2register.cpp:1005
sSDIXmitEnableShifts
static const ULWord sSDIXmitEnableShifts[]
Definition: ntv2register.cpp:3857
CNTV2Card::GetQuadFrameEnable
virtual bool GetQuadFrameEnable(bool &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device's current quad-frame mode, whether it's enabled or not.
Definition: ntv2register.cpp:1209
CNTV2Card::GetMixerMode
virtual bool GetMixerMode(const UWord inWhichMixer, NTV2MixerKeyerMode &outMode)
Returns the current operating mode of the given mixer/keyer.
Definition: ntv2register.cpp:2993
CNTV2Card::ReadAnalogLTCInput
virtual bool ReadAnalogLTCInput(const UWord inLTCInput, RP188_STRUCT &outRP188Data)
Reads the current contents of the device's analog LTC input registers.
Definition: ntv2register.cpp:3759
NTV2_FG_2048x1080
@ NTV2_FG_2048x1080
2048x1080, for 2Kx1080p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:355
kRegShiftRP188ModeCh7
@ kRegShiftRP188ModeCh7
Definition: ntv2publicinterface.h:2373
NTV2_STANDARD_4096HFR
@ NTV2_STANDARD_4096HFR
Identifies high frame-rate 4K.
Definition: ntv2enums.h:172
gChannelToSmpte372RegisterNum
static const ULWord gChannelToSmpte372RegisterNum[]
Definition: ntv2register.cpp:126
NTV2_STANDARD_4096x2160p
@ NTV2_STANDARD_4096x2160p
Identifies 4K.
Definition: ntv2enums.h:170
CNTV2Card::GetInputVideoSelect
virtual bool GetInputVideoSelect(NTV2InputVideoSelect &outInputSelect)
Definition: ntv2register.cpp:3421
kRegMaskInput2GeometryHigh
@ kRegMaskInput2GeometryHigh
Definition: ntv2publicinterface.h:1428
NTV2_FORMAT_1080p_2K_4800_A
@ NTV2_FORMAT_1080p_2K_4800_A
Definition: ntv2enums.h:626
NTV2_FORMAT_4x2048x1080p_11988
@ NTV2_FORMAT_4x2048x1080p_11988
Definition: ntv2enums.h:616
gChlToRP188DBBRegNum
static const ULWord gChlToRP188DBBRegNum[]
Definition: ntv2register.cpp:115
NTV2SetRegisters::mOutBadRegIndexes
NTV2Buffer mOutBadRegIndexes
Array of UWords containing index numbers of the register writes that failed. The SDK owns this memory...
Definition: ntv2publicinterface.h:7804
kRegCh1Control2MFrame
@ kRegCh1Control2MFrame
Definition: ntv2publicinterface.h:694
NTV2_FG_INVALID
@ NTV2_FG_INVALID
Definition: ntv2enums.h:371
NTV2_FRAMERATE_12000
@ NTV2_FRAMERATE_12000
120 frames per second
Definition: ntv2enums.h:420
kRegMaskSDIIn16GbpsMode
@ kRegMaskSDIIn16GbpsMode
Definition: ntv2publicinterface.h:1978
CNTV2Card::GetVideoLimiting
virtual bool GetVideoLimiting(NTV2VideoLimiting &outValue)
Answers with the current video range limiting mode for the device.
Definition: ntv2register.cpp:2681
kRegRXSDI5Status
@ kRegRXSDI5Status
Definition: ntv2publicinterface.h:756
gChannelToSDIIn6GModeShift
static const ULWord gChannelToSDIIn6GModeShift[]
Definition: ntv2register.cpp:140
kRegShiftFrameFormat
@ kRegShiftFrameFormat
Definition: ntv2publicinterface.h:2397
CVIDINFO
#define CVIDINFO(__x__)
Definition: ntv2register.cpp:29
NTV2_FORMAT_1080i_5994
@ NTV2_FORMAT_1080i_5994
Definition: ntv2enums.h:542
kRegMaskAlphaFromInput2
@ kRegMaskAlphaFromInput2
Definition: ntv2publicinterface.h:1307
kRegOutputTimingControlch3
@ kRegOutputTimingControlch3
Definition: ntv2publicinterface.h:669
YCbCr10BitPixel::cr
UWord cr
Definition: ntv2videodefines.h:204
CNTV2Card::GetRP188BypassSource
virtual bool GetRP188BypassSource(const NTV2Channel inSDIOutput, UWord &outSDIInput)
For the given SDI output that's in RP188 bypass mode (E-E), answers with the SDI input that's current...
Definition: ntv2register.cpp:2654
kRegShiftQuadQuadSquaresMode
@ kRegShiftQuadQuadSquaresMode
Definition: ntv2publicinterface.h:2380
CNTV2Card::SetSDIOut6GEnable
virtual bool SetSDIOut6GEnable(const NTV2Channel inChannel, const bool inEnable)
Definition: ntv2register.cpp:3949
CNTV2Card::GetAnalogInputVideoFormat
virtual NTV2VideoFormat GetAnalogInputVideoFormat(void)
Returns the video format of the signal that is present on the device's analog video input.
Definition: ntv2register.cpp:3561
kRegMaskRP188SourceSelect
@ kRegMaskRP188SourceSelect
Definition: ntv2publicinterface.h:1431
NTV2_FRAMERATE_INVALID
@ NTV2_FRAMERATE_INVALID
Definition: ntv2enums.h:435
ntv2endian.h
Defines a number of handy byte-swapping macros.
CNTV2Card::GetEnable4KDCYCC444Mode
virtual bool GetEnable4KDCYCC444Mode(bool &outIsEnabled)
Definition: ntv2register.cpp:4220
kRegShiftSDIIn23GbpsMode
@ kRegShiftSDIIn23GbpsMode
Definition: ntv2publicinterface.h:3047
kRegMaskVidProcBGMatteEnable
@ kRegMaskVidProcBGMatteEnable
Definition: ntv2publicinterface.h:1346
NTV2_FORMAT_4x1920x1080psf_3000
@ NTV2_FORMAT_4x1920x1080psf_3000
Definition: ntv2enums.h:603
NTV2_FRAMEBUFFER_ORIENTATION_NORMAL
@ NTV2_FRAMEBUFFER_ORIENTATION_NORMAL
Definition: ntv2enums.h:2037
kRegShiftSDIIn73GbpsSMPTELevelBMode
@ kRegShiftSDIIn73GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3088
kRegMaskGeometry
@ kRegMaskGeometry
Definition: ntv2publicinterface.h:1237
kDeviceCanDo4KVideo
@ kDeviceCanDo4KVideo
True if the device can handle 4K/UHD video.
Definition: ntv2devicefeatures.h:44
kRegShiftSDI5Transmit
@ kRegShiftSDI5Transmit
Definition: ntv2publicinterface.h:3146
NTV2_FRAMESIZE_18MB
@ NTV2_FRAMESIZE_18MB
Definition: ntv2enums.h:2115
kRegRP188InOut4Bits0_31
@ kRegRP188InOut4Bits0_31
Definition: ntv2publicinterface.h:415
kDeviceCanReportRunningFirmwareDate
@ kDeviceCanReportRunningFirmwareDate
True if device can report its running (and not necessarily installed) firmware date.
Definition: ntv2devicefeatures.h:133
CNTV2Card::GetRunningFirmwareDate
virtual bool GetRunningFirmwareDate(UWord &outYear, UWord &outMonth, UWord &outDay)
Reports the (local Pacific) build date of the currently-running firmware.
Definition: ntv2register.cpp:2378
NTV2_FORMAT_1080p_2K_3000
@ NTV2_FORMAT_1080p_2K_3000
Definition: ntv2enums.h:623
NTV2_FORMAT_4096x2160psf_2997
@ NTV2_FORMAT_4096x2160psf_2997
Definition: ntv2enums.h:660
kRegShiftSDIIn53GbpsMode
@ kRegShiftSDIIn53GbpsMode
Definition: ntv2publicinterface.h:3073
CNTV2Card::SetProgressivePicture
virtual bool SetProgressivePicture(ULWord value)
Definition: ntv2register.cpp:1072
NTV2_FORMAT_4x2048x1080p_2997
@ NTV2_FORMAT_4x2048x1080p_2997
Definition: ntv2enums.h:604
CNTV2Card::GetSDIWatchdogEnable
virtual bool GetSDIWatchdogEnable(bool &outIsEnabled, const UWord inIndex0)
Answers true if the given connector pair relays are under watchdog timer control, or false if they're...
Definition: ntv2register.cpp:4161
kRegMaskSmpte372Enable
@ kRegMaskSmpte372Enable
Definition: ntv2publicinterface.h:1241
CNTV2Card::DisableChannel
virtual bool DisableChannel(const NTV2Channel inChannel)
Disables the given FrameStore.
Definition: ntv2register.cpp:2141
gChannelToSmpte372Masks
static const ULWord gChannelToSmpte372Masks[]
Definition: ntv2register.cpp:128
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:7061
NTV2_IS_QUAD_QUAD_FRAME_GEOMETRY
#define NTV2_IS_QUAD_QUAD_FRAME_GEOMETRY(geom)
Definition: ntv2enums.h:376
kRegMaskSDIOut6GbpsMode
@ kRegMaskSDIOut6GbpsMode
Definition: ntv2publicinterface.h:1673
gChannelToSDIInput3GStatusRegNum
static const ULWord gChannelToSDIInput3GStatusRegNum[]
Definition: ntv2register.cpp:91
kDeviceCanDo3GLevelConversion
@ kDeviceCanDo3GLevelConversion
True if device can do 3G level B to 3G level A conversion.
Definition: ntv2devicefeatures.h:41
kK2RegShiftPulldownMode
@ kK2RegShiftPulldownMode
Definition: ntv2publicinterface.h:2837
kRegMaskRP188DBB
@ kRegMaskRP188DBB
Definition: ntv2publicinterface.h:1432
CNTV2Card::GetSDIInput12GPresent
virtual bool GetSDIInput12GPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3702
CNTV2Card::GetSDIOut6GEnable
virtual bool GetSDIOut6GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3959
kRegGlobalControlCh4
@ kRegGlobalControlCh4
Definition: ntv2publicinterface.h:547
kRegShiftInput1FrameRateHigh
@ kRegShiftInput1FrameRateHigh
Definition: ntv2publicinterface.h:2517
CNTV2Card::GetFramePulseReference
virtual bool GetFramePulseReference(NTV2ReferenceSource &outRefSource)
Answers with the device's current frame pulse reference source.
Definition: ntv2register.cpp:1611
SSC_GET_FIRMWARE_PROGRESS_STRUCT
Definition: ntv2publicinterface.h:5067
NTV2_FORMAT_4x4096x2160p_2500
@ NTV2_FORMAT_4x4096x2160p_2500
Definition: ntv2enums.h:701
kRegMaskInput2FrameRateHigh
@ kRegMaskInput2FrameRateHigh
Definition: ntv2publicinterface.h:1426
NTV2DeviceID
NTV2DeviceID
Identifies a specific AJA NTV2 device model number. The NTV2DeviceID is actually the PROM part number...
Definition: ntv2enums.h:20
kRegMaskSDIIn312GbpsMode
@ kRegMaskSDIIn312GbpsMode
Definition: ntv2publicinterface.h:1999
kRegMaskSDIIn63GbpsSMPTELevelBMode
@ kRegMaskSDIIn63GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2017
DEC0N
#define DEC0N(__x__, __n__)
Definition: ntv2publicinterface.h:5767
kRegShiftInput2FrameRateHigh
@ kRegShiftInput2FrameRateHigh
Definition: ntv2publicinterface.h:2518
kRegRXSDI7CRCErrorCount
@ kRegRXSDI7CRCErrorCount
Definition: ntv2publicinterface.h:775
CNTV2Card::GetInputFrame
virtual bool GetInputFrame(const NTV2Channel inChannel, ULWord &outValue)
Answers with the current input frame index number for the given FrameStore. This identifies which par...
Definition: ntv2register.cpp:2282
CNTV2Card::SetDualLinkInputEnable
virtual bool SetDualLinkInputEnable(const bool inIsEnabled)
Definition: ntv2register.cpp:3220
kRegMaskRP188ModeCh5
@ kRegMaskRP188ModeCh5
Definition: ntv2publicinterface.h:1278
kDeviceGetNumVideoOutputs
@ kDeviceGetNumVideoOutputs
The number of SDI video outputs on the device.
Definition: ntv2devicefeatures.h:213
NTV2_FORMAT_4x4096x2160p_4795
@ NTV2_FORMAT_4x4096x2160p_4795
Definition: ntv2enums.h:704
kRegMask425FB12
@ kRegMask425FB12
Definition: ntv2publicinterface.h:1272
GetQuarterSizedStandard
NTV2Standard GetQuarterSizedStandard(const NTV2Standard inGeometry)
Definition: ntv2utils.cpp:2244
NTV2_FORMAT_4x1920x1080p_2997
@ NTV2_FORMAT_4x1920x1080p_2997
Definition: ntv2enums.h:600
NTV2_FORMAT_4x1920x1080p_2500
@ NTV2_FORMAT_4x1920x1080p_2500
Definition: ntv2enums.h:593
CNTV2Card::EnableRP188Bypass
virtual bool EnableRP188Bypass(const NTV2Channel inSDIOutput)
Configures the SDI output's embedder to embed SMPTE 12M timecode obtained from an SDI input,...
Definition: ntv2register.cpp:2635
NTV2FormatDescriptor::GetRasterHeight
ULWord GetRasterHeight(const bool inVisibleOnly=false) const
Definition: ntv2formatdescriptor.h:188
CNTV2Card::SetOutputFrame
virtual bool SetOutputFrame(const NTV2Channel inChannel, const ULWord inValue)
Sets the output frame index number for the given FrameStore. This identifies which frame in device SD...
Definition: ntv2register.cpp:2255
kRegRP188InOut5DBB
@ kRegRP188InOut5DBB
Definition: ntv2publicinterface.h:497
kRegGlobalControlCh7
@ kRegGlobalControlCh7
Definition: ntv2publicinterface.h:550
NTV2_FBF_INVALID
@ NTV2_FBF_INVALID
Definition: ntv2enums.h:251
NTV2_FORMAT_4x2048x1080p_4800
@ NTV2_FORMAT_4x2048x1080p_4800
Definition: ntv2enums.h:615
kRegRP188InOut3Bits0_31
@ kRegRP188InOut3Bits0_31
Definition: ntv2publicinterface.h:410
NTV2FrameBufferFormat
NTV2FrameBufferFormat
Identifies a particular video frame buffer format. See Device Frame Buffer Formats for details.
Definition: ntv2enums.h:213
NTV2_FORMAT_4x3840x2160p_2500
@ NTV2_FORMAT_4x3840x2160p_2500
Definition: ntv2enums.h:688
WriteWatchdogControlBit
static bool WriteWatchdogControlBit(CNTV2Card &card, const ULWord inValue, const ULWord inMask, const ULWord inShift)
Definition: ntv2register.cpp:4087
kRegMaskLTCInPresent
@ kRegMaskLTCInPresent
Definition: ntv2publicinterface.h:1358
kDeviceCanDoFramePulseSelect
@ kDeviceCanDoFramePulseSelect
True if device supports frame pulse source independent of reference source.
Definition: ntv2devicefeatures.h:125
kRegRXSDI8CRCErrorCount
@ kRegRXSDI8CRCErrorCount
Definition: ntv2publicinterface.h:784
NTV2_IS_QUAD_QUAD_STANDARD
#define NTV2_IS_QUAD_QUAD_STANDARD(__s__)
Definition: ntv2enums.h:206
kDeviceCanDo12gRouting
@ kDeviceCanDo12gRouting
True if device supports 12G routing crosspoints.
Definition: ntv2devicefeatures.h:117
NTV2_REFERENCE_SFP2_PTP
@ NTV2_REFERENCE_SFP2_PTP
Specifies the PTP source on SFP 2.
Definition: ntv2enums.h:1459
kRegCh8OutputFrame
@ kRegCh8OutputFrame
Definition: ntv2publicinterface.h:569
kRegMaskLTC2InPresent
@ kRegMaskLTC2InPresent
Definition: ntv2publicinterface.h:1967
kRegShiftSDIRelayControl34
@ kRegShiftSDIRelayControl34
Definition: ntv2publicinterface.h:3157
kRegShiftSDIIn3GbpsMode
@ kRegShiftSDIIn3GbpsMode
Definition: ntv2publicinterface.h:3040
kRegCh4Control2MFrame
@ kRegCh4Control2MFrame
Definition: ntv2publicinterface.h:697
NTV2_FG_720x486
@ NTV2_FG_720x486
720x486, for NTSC 525i and 525p60, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:347
kRegMaskQuadQuadMode
@ kRegMaskQuadQuadMode
Definition: ntv2publicinterface.h:1287
CNTV2Card::SetSDI1OutHTiming
virtual bool SetSDI1OutHTiming(ULWord value)
Definition: ntv2register.cpp:3396
kRegShiftSDIInCRCErrorCountB
@ kRegShiftSDIInCRCErrorCountB
Definition: ntv2publicinterface.h:3185
kRegRXSDI1Status
@ kRegRXSDI1Status
Definition: ntv2publicinterface.h:720
kDeviceCanDoVersalSysMon
@ kDeviceCanDoVersalSysMon
True if device supports Versal Adaptive SoC System Monitor.
Definition: ntv2devicefeatures.h:158
kRegShiftSDI7Transmit
@ kRegShiftSDI7Transmit
Definition: ntv2publicinterface.h:3148
kRegShiftSDIIn53GbpsSMPTELevelBMode
@ kRegShiftSDIIn53GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3074
CNTV2Card::GetVANCMode
virtual bool GetVANCMode(NTV2VANCMode &outVancMode, const NTV2Channel inChannel=NTV2_CHANNEL1)
Retrieves the current VANC mode for the given FrameStore.
Definition: ntv2register.cpp:2792
kRegVidProc3Control
@ kRegVidProc3Control
Definition: ntv2publicinterface.h:676
kRegLTCAnalogBits32_63
@ kRegLTCAnalogBits32_63
Definition: ntv2publicinterface.h:239
CNTV2Card::GetAllWidgetInputs
virtual bool GetAllWidgetInputs(NTV2InputXptIDSet &outInputs)
Returns all my widget input crosspoints.
Definition: ntv2register.cpp:1825
kRegShiftVidProcRGBRange
@ kRegShiftVidProcRGBRange
Definition: ntv2publicinterface.h:2436
CNTV2Card::GetMultiFormatMode
virtual bool GetMultiFormatMode(bool &outIsEnabled)
Answers if the device is operating in multiple-format per channel (independent channel) mode or not....
Definition: ntv2register.cpp:4437
kRegMaskQuadQuadSquaresMode
@ kRegMaskQuadQuadSquaresMode
Definition: ntv2publicinterface.h:1289
CNTV2Card::GetSDIRelayManualControl
virtual bool GetSDIRelayManualControl(NTV2RelayState &outValue, const UWord inIndex0)
Answers if the bypass relays between connectors 1 and 2 would be in bypass or would route signals thr...
Definition: ntv2register.cpp:4133
CNTV2Card::SupportsP2PTransfer
virtual bool SupportsP2PTransfer(void)
Definition: ntv2register.cpp:2469
CNTV2Card::GetLTCEmbeddedOutEnable
virtual bool GetLTCEmbeddedOutEnable(bool &outValue)
Definition: ntv2register.cpp:3753
CNTV2VPID::GetProgressivePicture
virtual bool GetProgressivePicture(void) const
Definition: ntv2vpid.cpp:346
NTV2_IS_QUAD_STANDARD
#define NTV2_IS_QUAD_STANDARD(__s__)
Definition: ntv2enums.h:202
AJA_UNUSED
#define AJA_UNUSED(_x_)
Definition: types.h:424
CNTV2Card::FlipFlopPage
virtual bool FlipFlopPage(const NTV2Channel inChannel)
Definition: ntv2register.cpp:2244
NTV2ChannelSetConstIter
NTV2ChannelSet::const_iterator NTV2ChannelSetConstIter
A handy const iterator into an NTV2ChannelSet.
Definition: ntv2publicinterface.h:3939
kRegShift4KDCPSFInMode
@ kRegShift4KDCPSFInMode
Definition: ntv2publicinterface.h:3169
CNTV2Card::MixerHasRGBModeSupport
virtual bool MixerHasRGBModeSupport(const UWord inWhichMixer, bool &outIsSupported)
Answers if the given mixer/keyer's has RGB mode support.
Definition: ntv2register.cpp:3110
kRegShiftSDI6Transmit
@ kRegShiftSDI6Transmit
Definition: ntv2publicinterface.h:3147
kRegShiftRP188DBB
@ kRegShiftRP188DBB
Definition: ntv2publicinterface.h:2524
CNTV2Card::SetFrameGeometry
virtual bool SetFrameGeometry(NTV2FrameGeometry inGeometry, bool inIsRetail=(!(0)), NTV2Channel inChannel=NTV2_CHANNEL1)
Sets the frame geometry of the given channel.
Definition: ntv2register.cpp:897
CNTV2Card::WriteOutputTimingControl
virtual bool WriteOutputTimingControl(const ULWord inValue, const UWord inOutputSpigot=0)
Adjusts the output timing for the given SDI output connector.
Definition: ntv2register.cpp:3355
kRegShiftLED
@ kRegShiftLED
Definition: ntv2publicinterface.h:2335
NTV2_CHANNEL1
@ NTV2_CHANNEL1
Specifies channel or FrameStore 1 (or the first item).
Definition: ntv2enums.h:1348
CNTV2Card::ReadFlashProgramControl
virtual bool ReadFlashProgramControl(ULWord &outValue)
Definition: ntv2register.cpp:2299
NTV2RelayState
NTV2RelayState
This enumerated data type identifies the two possible states of the bypass relays....
Definition: ntv2enums.h:3914
NTV2_IS_2K_1080_FRAME_GEOMETRY
#define NTV2_IS_2K_1080_FRAME_GEOMETRY(geom)
Definition: ntv2enums.h:382
CNTV2Card::SetFrameBufferFormat
virtual bool SetFrameBufferFormat(NTV2Channel inChannel, NTV2FrameBufferFormat inNewFormat, bool inIsAJARetail=(!(0)), NTV2HDRXferChars inXferChars=NTV2_VPID_TC_SDR_TV, NTV2HDRColorimetry inColorimetry=NTV2_VPID_Color_Rec709, NTV2HDRLuminance inLuminance=NTV2_VPID_Luminance_YCbCr)
Sets the frame buffer format for the given FrameStore on the AJA device.
Definition: ntv2register.cpp:1876
CNTV2Card::SetSDITransmitEnable
virtual bool SetSDITransmitEnable(const NTV2Channel inChannel, const bool inEnable)
Sets the specified bidirectional SDI connector to act as an input or an output.
Definition: ntv2register.cpp:3860
kRegMaskFramePulseEnable
@ kRegMaskFramePulseEnable
Definition: ntv2publicinterface.h:1291
kRegLTC2AnalogBits32_63
@ kRegLTC2AnalogBits32_63
Definition: ntv2publicinterface.h:396
NTV2_FORMAT_4x3840x2160p_2398
@ NTV2_FORMAT_4x3840x2160p_2398
Definition: ntv2enums.h:686
kRegMaskSDIOut12GbpsMode
@ kRegMaskSDIOut12GbpsMode
Definition: ntv2publicinterface.h:1674
kRegShiftVidProcBGMatteEnable
@ kRegShiftVidProcBGMatteEnable
Definition: ntv2publicinterface.h:2438
kRegShift425FB12
@ kRegShift425FB12
Definition: ntv2publicinterface.h:2365
kRegMaskSDIIn76GbpsMode
@ kRegMaskSDIIn76GbpsMode
Definition: ntv2publicinterface.h:2028
CNTV2Card::GetSDITransmitEnable
virtual bool GetSDITransmitEnable(const NTV2Channel inChannel, bool &outEnabled)
Answers whether or not the specified SDI connector is currently acting as a transmitter (i....
Definition: ntv2register.cpp:3881
kRegMaskDualLinkOutEnable
@ kRegMaskDualLinkOutEnable
Definition: ntv2publicinterface.h:1247
NTV2FrameSize
Describes the horizontal and vertical size dimensions of a raster, bitmap, frame or image.
Definition: ntv2publicinterface.h:5812
kRegShiftInput2GeometryHigh
@ kRegShiftInput2GeometryHigh
Definition: ntv2publicinterface.h:2520
kRegRP188InOut4Bits32_63
@ kRegRP188InOut4Bits32_63
Definition: ntv2publicinterface.h:416
CNTV2Card::SetVANCShiftMode
virtual bool SetVANCShiftMode(NTV2Channel inChannel, NTV2VANCDataShiftMode inMode)
Enables or disables the "VANC Shift Mode" feature for the given channel.
Definition: ntv2register.cpp:2864
kRegShiftSDIIn66GbpsMode
@ kRegShiftSDIIn66GbpsMode
Definition: ntv2publicinterface.h:3085
CNTV2Card::GetFrameBufferFormat
virtual bool GetFrameBufferFormat(NTV2Channel inChannel, NTV2FrameBufferFormat &outValue)
Returns the current frame buffer format for the given FrameStore on the AJA device.
Definition: ntv2register.cpp:1939
NTV2SDIInputStatus::mFrameTRSError
bool mFrameTRSError
If true, SAV/EAV was missing, or the SDI framer had to realign, or "RX Locked" went inactive....
Definition: ntv2publicinterface.h:7113
kRegMaskSDIIn63GbpsMode
@ kRegMaskSDIIn63GbpsMode
Definition: ntv2publicinterface.h:2016
CNTV2Card::GetEnable4KDCPSFInMode
virtual bool GetEnable4KDCPSFInMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4233
kRegMaskInput1FrameRate
@ kRegMaskInput1FrameRate
Definition: ntv2publicinterface.h:1412
kRegShiftInput1FrameRate
@ kRegShiftInput1FrameRate
Definition: ntv2publicinterface.h:2504
kVRegSecondaryFormatSelect
@ kVRegSecondaryFormatSelect
Definition: ntv2virtualregisters.h:43
K2_NOMINAL_V
#define K2_NOMINAL_V
Definition: ntv2register.cpp:47
NTV2_STANDARD_UNDEFINED
@ NTV2_STANDARD_UNDEFINED
Definition: ntv2enums.h:178
CNTV2Card::GetXena2FlashBaseAddress
virtual bool GetXena2FlashBaseAddress(ULWord **pXena2FlashAddress)
Definition: ntv2register.cpp:3198
nlohmann::json_abiNLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON_v3_11_NLOHMANN_JSON_VERSION_PATCH::detail::void
j template void())
Definition: json.hpp:4893
kDeviceCanChangeFrameBufferSize
@ kDeviceCanChangeFrameBufferSize
True if frame buffer sizes are not fixed.
Definition: ntv2devicefeatures.h:38
kRegCh2PCIAccessFrame
@ kRegCh2PCIAccessFrame
Definition: ntv2publicinterface.h:126
kLHIRegShiftSDIOutSMPTELevelBMode
@ kLHIRegShiftSDIOutSMPTELevelBMode
Definition: ntv2publicinterface.h:2763
CNTV2Card::GetSDIOut2Kx1080Enable
virtual bool GetSDIOut2Kx1080Enable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3913
kK2RegShiftSDIOutStandard
@ kK2RegShiftSDIOutStandard
Definition: ntv2publicinterface.h:2753
kFS1RefShiftLTCEmbeddedOutEnable
@ kFS1RefShiftLTCEmbeddedOutEnable
Definition: ntv2publicinterface.h:2635
NTV2_FRAMERATE_2500
@ NTV2_FRAMERATE_2500
25 frames per second
Definition: ntv2enums.h:414
kRegSysmonVccIntDieTemp
@ kRegSysmonVccIntDieTemp
Definition: ntv2publicinterface.h:251
kK2RegMaskPulldownMode
@ kK2RegMaskPulldownMode
Definition: ntv2publicinterface.h:1758
kVRegDefaultVideoOutMode
@ kVRegDefaultVideoOutMode
Definition: ntv2virtualregisters.h:235
CNTV2Card::GetQuadQuadSquaresEnable
virtual bool GetQuadQuadSquaresEnable(bool &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device's current "quad-quad-squares" frame mode, whether it's enabled or not.
Definition: ntv2register.cpp:1197
NTV2_FORMAT_1080p_2K_4795_A
@ NTV2_FORMAT_1080p_2K_4795_A
Definition: ntv2enums.h:625
CNTV2Card::Enable4KDCYCC444Mode
virtual bool Enable4KDCYCC444Mode(bool inEnable)
Sets 4K Down Convert YCC 444 mode.
Definition: ntv2register.cpp:4215
NTV2_FORMAT_3840x2160p_2500
@ NTV2_FORMAT_3840x2160p_2500
Definition: ntv2enums.h:639
kRegShiftFrameRateHiBit
@ kRegShiftFrameRateHiBit
Definition: ntv2publicinterface.h:2329
kRegShiftQuadQuadMode
@ kRegShiftQuadQuadMode
Definition: ntv2publicinterface.h:2378
kRegShiftSDIIn46GbpsMode
@ kRegShiftSDIIn46GbpsMode
Definition: ntv2publicinterface.h:3069
kRegShiftFrameFormatHiBit
@ kRegShiftFrameFormatHiBit
Definition: ntv2publicinterface.h:2398
kRegMaskSDIIn112GbpsMode
@ kRegMaskSDIIn112GbpsMode
Definition: ntv2publicinterface.h:1979
NTV2FrameRate
NTV2FrameRate
Identifies a particular video frame rate.
Definition: ntv2enums.h:406
kVRegFlashSize
@ kVRegFlashSize
Definition: ntv2virtualregisters.h:301
NTV2_INPUTSOURCE_HDMI3
@ NTV2_INPUTSOURCE_HDMI3
Identifies the 3rd HDMI video input.
Definition: ntv2enums.h:1261
kRegMaskVidProcRGBRange
@ kRegMaskVidProcRGBRange
Definition: ntv2publicinterface.h:1344
NTV2_CHANNEL6
@ NTV2_CHANNEL6
Specifies channel or FrameStore 6 (or the 6th item).
Definition: ntv2enums.h:1353
NTV2SDIInputStatus
For devices that support it (see NTV2DeviceCanDoSDIErrorChecks ), this struct reports SDI input error...
Definition: ntv2publicinterface.h:7104
ntv2registersmb.h
Defines the KonaIP/IoIP registers.
kRegMaskLTC1InPresent
@ kRegMaskLTC1InPresent
Definition: ntv2publicinterface.h:1965
kRegMaskVidProcVancSource
@ kRegMaskVidProcVancSource
Definition: ntv2publicinterface.h:1343
NTV2SDIInputStatus::mUnlockTally
ULWord mUnlockTally
The number of times "RX Locked" went inactive since this tally was last reset.
Definition: ntv2publicinterface.h:7109
CNTV2Card::WriteRegisters
virtual bool WriteRegisters(const NTV2RegisterWrites &inRegWrites)
Writes the given sequence of NTV2RegInfo's.
Definition: ntv2register.cpp:4642
CNTV2Card::SetFrameBufferQuality
virtual bool SetFrameBufferQuality(NTV2Channel inChannel, NTV2FrameBufferQuality inValue)
Definition: ntv2register.cpp:1977
CNTV2Card::GetMixerBGMatteEnabled
virtual bool GetMixerBGMatteEnabled(const UWord inWhichMixer, bool &outIsEnabled)
Answers if the given mixer/keyer's background matte is enabled or not.
Definition: ntv2register.cpp:3053
gChannelToSDIInputProgressiveShift
static const ULWord gChannelToSDIInputProgressiveShift[]
Definition: ntv2register.cpp:172
NTV2_FORMAT_2K_2398
@ NTV2_FORMAT_2K_2398
Definition: ntv2enums.h:583
NTV2_FORMAT_4x4096x2160p_2997
@ NTV2_FORMAT_4x4096x2160p_2997
Definition: ntv2enums.h:702
kDeviceHasSDIRelays
@ kDeviceHasSDIRelays
True if device has bypass relays on its SDI connectors.
Definition: ntv2devicefeatures.h:98
NTV2RegNumSet
NTV2RegisterNumberSet NTV2RegNumSet
A set of distinct NTV2RegisterNumbers.
Definition: ntv2publicinterface.h:7657
NTV2_FRAMERATE_4800
@ NTV2_FRAMERATE_4800
48 frames per second
Definition: ntv2enums.h:418
CNTV2Card::GetRunningFirmwareUserID
virtual bool GetRunningFirmwareUserID(ULWord &outUserID)
Reports the UserID number of the currently-running firmware.
Definition: ntv2register.cpp:2450
kRegShiftAlphaFromInput2
@ kRegShiftAlphaFromInput2
Definition: ntv2publicinterface.h:2399
NTV2MixerKeyerInputControl
NTV2MixerKeyerInputControl
These enum values identify the Mixer/Keyer foreground and background input control values.
Definition: ntv2enums.h:1765
NTV2_FORMAT_4096x2160psf_2400
@ NTV2_FORMAT_4096x2160psf_2400
Definition: ntv2enums.h:653
IsProgressivePicture
bool IsProgressivePicture(const NTV2VideoFormat format)
Definition: ntv2utils.cpp:5291
NTV2_CHANNEL4
@ NTV2_CHANNEL4
Specifies channel or FrameStore 4 (or the 4th item).
Definition: ntv2enums.h:1351
kRegRP188InOut6Bits32_63
@ kRegRP188InOut6Bits32_63
Definition: ntv2publicinterface.h:592
NTV2BankSelGetSetRegs
This is used to atomically perform bank-selected register reads or writes.
Definition: ntv2publicinterface.h:7862
kRegCh3Control
@ kRegCh3Control
Definition: ntv2publicinterface.h:398
kRegMaskSDIOutLevelAtoLevelB
@ kRegMaskSDIOutLevelAtoLevelB
Definition: ntv2publicinterface.h:1676
kRegShiftSDIIn63GbpsSMPTELevelBMode
@ kRegShiftSDIIn63GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3081
NTV2HDRXferChars
enum NTV2VPIDTransferCharacteristics NTV2HDRXferChars
NTV2_RS422_PARITY
NTV2_RS422_PARITY
These enum values identify RS-422 serial port parity configuration.
Definition: ntv2enums.h:4140
CNTV2Card::GetSDIOutputDS2AudioSystem
virtual bool GetSDIOutputDS2AudioSystem(const NTV2Channel inSDIOutputConnector, NTV2AudioSystem &outAudioSystem)
Answers with the device's Audio System that is currently providing audio for the given SDI output's a...
Definition: ntv2register.cpp:4045
NTV2_MODE_INPUT
@ NTV2_MODE_INPUT
Input (capture) mode, which writes into device SDRAM.
Definition: ntv2enums.h:1238
kRegMaskSDIRelayPosition34
@ kRegMaskSDIRelayPosition34
Definition: ntv2publicinterface.h:2101
kRegCh5Control2MFrame
@ kRegCh5Control2MFrame
Definition: ntv2publicinterface.h:698
ULWordSetConstIter
ULWordSet::const_iterator ULWordSetConstIter
Definition: ntv2publicinterface.h:55
CNTV2Card::GetSDILock
virtual bool GetSDILock(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4266
kRegShiftSDIIn5LevelBtoLevelA
@ kRegShiftSDIIn5LevelBtoLevelA
Definition: ntv2publicinterface.h:3075
kRegMaskEncodeAsPSF
@ kRegMaskEncodeAsPSF
Definition: ntv2publicinterface.h:1318
NTV2DeviceNeedsRoutingSetup
bool NTV2DeviceNeedsRoutingSetup(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8722
kRegMaskAutodetect64
@ kRegMaskAutodetect64
Definition: ntv2publicinterface.h:1436
NTV2_CHANNEL5
@ NTV2_CHANNEL5
Specifies channel or FrameStore 5 (or the 5th item).
Definition: ntv2enums.h:1352
kRegMaskSDIWatchdogEnable12
@ kRegMaskSDIWatchdogEnable12
Definition: ntv2publicinterface.h:2098
NTV2_FRAMERATE_2400
@ NTV2_FRAMERATE_2400
24 frames per second
Definition: ntv2enums.h:415
kRegOutputTimingControlch5
@ kRegOutputTimingControlch5
Definition: ntv2publicinterface.h:671
kK2RegMaskSDIOutDS1Audio_Bit1
@ kK2RegMaskSDIOutDS1Audio_Bit1
Definition: ntv2publicinterface.h:1682
CNTV2DriverInterface::ReadRegister
virtual bool ReadRegister(const ULWord inRegNum, ULWord &outValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Reads all or part of the 32-bit contents of a specific register (real or virtual) on the AJA device....
Definition: ntv2driverinterface.cpp:433
CNTV2Card::GetSDIInput6GPresent
virtual bool GetSDIInput6GPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3690
kRegCh2Control
@ kRegCh2Control
Definition: ntv2publicinterface.h:125
NTV2_FORMAT_4x2048x1080psf_2398
@ NTV2_FORMAT_4x2048x1080psf_2398
Definition: ntv2enums.h:594
NTV2_INPUTSOURCE_ANALOG1
@ NTV2_INPUTSOURCE_ANALOG1
Identifies the first analog video input.
Definition: ntv2enums.h:1258
NTV2_IS_3Gb_FORMAT
#define NTV2_IS_3Gb_FORMAT(__f__)
Definition: ntv2enums.h:969
kRegMaskRS422ParityDisable
@ kRegMaskRS422ParityDisable
Definition: ntv2publicinterface.h:1498
NTV2_FORMAT_4x2048x1080p_2398
@ NTV2_FORMAT_4x2048x1080p_2398
Definition: ntv2enums.h:597
kRegShiftSDI3Transmit
@ kRegShiftSDI3Transmit
Definition: ntv2publicinterface.h:3152
CNTV2Card::Enable4KDCPSFInMode
virtual bool Enable4KDCPSFInMode(bool inEnable)
Sets 4K Down Convert PSF in mode.
Definition: ntv2register.cpp:4228
isEnabled
static bool isEnabled(CNTV2Card &device, const NTV2Channel inChannel)
Definition: ntv2supportlogger.cpp:143
CNTV2Card::Enable4KDCRGBMode
virtual bool Enable4KDCRGBMode(bool inEnable)
Sets 4K Down Convert RGB mode.
Definition: ntv2register.cpp:4202
kVRegMailBoxAbort
@ kVRegMailBoxAbort
Definition: ntv2virtualregisters.h:415
CNTV2Card::GetPulldownMode
virtual bool GetPulldownMode(NTV2Channel inChannel, bool &outValue)
Definition: ntv2register.cpp:2903
kRegShiftInput2Geometry
@ kRegShiftInput2Geometry
Definition: ntv2publicinterface.h:2508
kRegMaskAnalogInputIntegerRate
@ kRegMaskAnalogInputIntegerRate
Definition: ntv2publicinterface.h:1581
NTV2_INPUTSOURCE_SDI1
@ NTV2_INPUTSOURCE_SDI1
Identifies the 1st SDI video input.
Definition: ntv2enums.h:1263
kRegRXSDIFreeRunningClockHigh
@ kRegRXSDIFreeRunningClockHigh
Definition: ntv2publicinterface.h:793
NTV2_FRAMESIZE_28MB
@ NTV2_FRAMESIZE_28MB
Definition: ntv2enums.h:2120
NTV2_REFERENCE_HDMI_INPUT4
@ NTV2_REFERENCE_HDMI_INPUT4
Specifies the HDMI In 4 connector.
Definition: ntv2enums.h:1463
CNTV2Card::GetReferenceVideoFormat
virtual NTV2VideoFormat GetReferenceVideoFormat(void)
Returns the video format of the signal that is present on the device's reference input.
Definition: ntv2register.cpp:3610
kRegGlobalControlCh8
@ kRegGlobalControlCh8
Definition: ntv2publicinterface.h:551
CNTV2Card::GetAnalogLTCInClockChannel
virtual bool GetAnalogLTCInClockChannel(const UWord inLTCInput, NTV2Channel &outChannel)
Answers with the (SDI) input channel that's providing the clock reference being used by the given dev...
Definition: ntv2register.cpp:3782
CNTV2Card::SetMixerBGMatteEnabled
virtual bool SetMixerBGMatteEnabled(const UWord inWhichMixer, const bool inIsEnabled)
Answers if the given mixer/keyer's background matte is enabled or not.
Definition: ntv2register.cpp:3061
NTV2InputXptIDSetConstIter
NTV2InputXptIDSet::const_iterator NTV2InputXptIDSetConstIter
A const iterator for iterating over an NTV2InputXptIDSet.
Definition: ntv2signalrouter.h:27
kRegMaskSDIRelayControl34
@ kRegMaskSDIRelayControl34
Definition: ntv2publicinterface.h:2097
BIT_20
#define BIT_20
Definition: ajatypes.h:594
kRegShiftSDIInUnlockCount
@ kRegShiftSDIInUnlockCount
Definition: ntv2publicinterface.h:3179
NTV2_RP188::fLo
ULWord fLo
| BG 4 | Secs10 | BG 3 | Secs 1 | BG 2 | Frms10 | BG 1 | Frms 1 |
Definition: ntv2publicinterface.h:7000
kRegMaskSDI7Transmit
@ kRegMaskSDI7Transmit
Definition: ntv2publicinterface.h:2088
HEXN
#define HEXN(__x__, __n__)
Definition: ntv2publicinterface.h:5761
GetNTV2StandardFromScanGeometry
NTV2Standard GetNTV2StandardFromScanGeometry(const UByte inScanGeometry, const bool inIsProgressiveTransport)
Definition: ntv2utils.cpp:1807
CNTV2Card::GetMixerMatteColor
virtual bool GetMixerMatteColor(const UWord inWhichMixer, YCbCr10BitPixel &outYCbCrValue)
Answers with the given mixer/keyer's current matte color value being used.
Definition: ntv2register.cpp:3070
CNTV2Card::GetMixerFGInputControl
virtual bool GetMixerFGInputControl(const UWord inWhichMixer, NTV2MixerKeyerInputControl &outInputControl)
Returns the current foreground input control value for the given mixer/keyer.
Definition: ntv2register.cpp:2947
gChannelToSDIIn6GModeMask
static const ULWord gChannelToSDIIn6GModeMask[]
Definition: ntv2register.cpp:137
kRegMaskQuadMode
@ kRegMaskQuadMode
Definition: ntv2publicinterface.h:1255
CNTV2Card::GetPossibleConnections
virtual bool GetPossibleConnections(NTV2PossibleConnections &outConnections)
Answers with the implemented crosspoint connections (if known).
Definition: ntv2register.cpp:1813
YCbCr10BitPixel
Definition: ntv2videodefines.h:200
CNTV2Card::GetVideoDACMode
virtual bool GetVideoDACMode(NTV2VideoDACMode &outValue)
Definition: ntv2register.cpp:3260
NTV2_FORMAT_1080psf_2K_2500
@ NTV2_FORMAT_1080psf_2K_2500
Definition: ntv2enums.h:567
NTV2_REFERENCE_INPUT5
@ NTV2_REFERENCE_INPUT5
Specifies the SDI In 5 connector.
Definition: ntv2enums.h:1453
NTV2_FORMAT_4x2048x1080psf_2400
@ NTV2_FORMAT_4x2048x1080psf_2400
Definition: ntv2enums.h:595
CNTV2Card::SetVideoLimiting
virtual bool SetVideoLimiting(const NTV2VideoLimiting inValue)
Sets the device's video range limiting mode.
Definition: ntv2register.cpp:2673
kRegSDIOut3Control
@ kRegSDIOut3Control
Definition: ntv2publicinterface.h:307
kRegShiftSDIIn36GbpsMode
@ kRegShiftSDIIn36GbpsMode
Definition: ntv2publicinterface.h:3062
kVRegEveryFrameTaskFilter
@ kVRegEveryFrameTaskFilter
Definition: ntv2virtualregisters.h:233
CNTV2Card::GetRP188Data
virtual bool GetRP188Data(const NTV2Channel inSDIInput, NTV2_RP188 &outRP188Data)
Reads the raw RP188 data from the DBB/Low/Hi registers for the given SDI input. On newer devices with...
Definition: ntv2register.cpp:2574
CNTV2Card::SetRP188SourceFilter
virtual bool SetRP188SourceFilter(const NTV2Channel inSDIInput, const UWord inFilterValue)
Sets the RP188 DBB filter for the given SDI input.
Definition: ntv2register.cpp:2597
MAIN_FLASHBLOCK
@ MAIN_FLASHBLOCK
Definition: ntv2enums.h:4254
kDeviceCanDoProgrammableRS422
@ kDeviceCanDoProgrammableRS422
True if device has at least one RS-422 serial port, and it (they) can be programmed (for baud rate,...
Definition: ntv2devicefeatures.h:77
kRegShiftRP188ModeCh3
@ kRegShiftRP188ModeCh3
Definition: ntv2publicinterface.h:2369
NTV2_FRAMESIZE_32MB
@ NTV2_FRAMESIZE_32MB
Definition: ntv2enums.h:2122
kRegShiftSDIInTRSError
@ kRegShiftSDIInTRSError
Definition: ntv2publicinterface.h:3183
kRegShiftGeometry
@ kRegShiftGeometry
Definition: ntv2publicinterface.h:2330
NTV2_FORMAT_1080p_5994_B
@ NTV2_FORMAT_1080p_5994_B
Definition: ntv2enums.h:559
NTV2_RP188::fHi
ULWord fHi
| BG 8 | Hrs 10 | BG 7 | Hrs 1 | BG 6 | Mins10 | BG 5 | Mins 1 |
Definition: ntv2publicinterface.h:7001
kRegSDIWatchdogKick2
@ kRegSDIWatchdogKick2
Definition: ntv2publicinterface.h:460
CNTV2Card::GetOutputFrame
virtual bool GetOutputFrame(const NTV2Channel inChannel, ULWord &outValue)
Answers with the current output frame number for the given FrameStore (expressed as an NTV2Channel).
Definition: ntv2register.cpp:2264
kRegCh5OutputFrame
@ kRegCh5OutputFrame
Definition: ntv2publicinterface.h:554
NTV2GetRegisters
This is used by the CNTV2Card::ReadRegisters function.
Definition: ntv2publicinterface.h:7686
kRegShiftSDIIn712GbpsMode
@ kRegShiftSDIIn712GbpsMode
Definition: ntv2publicinterface.h:3093
CNTV2Card::GetActiveFrameDimensions
virtual bool GetActiveFrameDimensions(NTV2FrameDimensions &outFrameDimensions, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:782
NTV2_FORMAT_1080psf_3000_2
@ NTV2_FORMAT_1080psf_3000_2
Definition: ntv2enums.h:570
NTV2_FORMAT_1080p_2K_2400
@ NTV2_FORMAT_1080p_2K_2400
Definition: ntv2enums.h:554
CNTV2Card::GetTsiMuxSyncFail
virtual bool GetTsiMuxSyncFail(bool &outSyncFailed, const NTV2Channel inWhichTsiMux)
Answers if the SMPTE 425 two-sample-interleave mux/demux input sync has failed or not.
Definition: ntv2register.cpp:1439
kDeviceCanDoRGBLevelAConversion
@ kDeviceCanDoRGBLevelAConversion
True if the device can do RGB over 3G Level A.
Definition: ntv2devicefeatures.h:42
kRegRP188InOut8Bits32_63
@ kRegRP188InOut8Bits32_63
Definition: ntv2publicinterface.h:612
NTV2_FG_2048x1588
@ NTV2_FG_2048x1588
2048x1556, for 2Kx1556psf film format, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:357
NTV2_RS422_BAUD_RATE_9600
@ NTV2_RS422_BAUD_RATE_9600
9600 baud
Definition: ntv2enums.h:4159
NTV2_FORMAT_525_2398
@ NTV2_FORMAT_525_2398
Definition: ntv2enums.h:575
NTV2_FORMAT_4x2048x1080p_3000
@ NTV2_FORMAT_4x2048x1080p_3000
Definition: ntv2enums.h:605
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:159
kRegShiftSDIIn3LevelBtoLevelA
@ kRegShiftSDIIn3LevelBtoLevelA
Definition: ntv2publicinterface.h:3059
NTV2_VANCMODE_OFF
@ NTV2_VANCMODE_OFF
This identifies the mode in which there are no VANC lines in the frame buffer.
Definition: ntv2enums.h:3777
gIndexToVidProcControlRegNum
static const ULWord gIndexToVidProcControlRegNum[]
Definition: ntv2register.cpp:100
kRegRXSDI4CRCErrorCount
@ kRegRXSDI4CRCErrorCount
Definition: ntv2publicinterface.h:748
BIT_21
#define BIT_21
Definition: ajatypes.h:595
NTV2_FORMAT_4096x2160p_4795
@ NTV2_FORMAT_4096x2160p_4795
Definition: ntv2enums.h:662
CNTV2Card::SetSecondaryVideoFormat
virtual bool SetSecondaryVideoFormat(NTV2VideoFormat inFormat)
Definition: ntv2register.cpp:3403
CNTV2Card::SetSDIOutputAudioSystem
virtual bool SetSDIOutputAudioSystem(const NTV2Channel inSDIOutputConnector, const NTV2AudioSystem inAudioSystem)
Sets the device's NTV2AudioSystem that will provide audio for the given SDI output's audio embedder....
Definition: ntv2register.cpp:4015
CNTV2Card::SupportsP2PTarget
virtual bool SupportsP2PTarget(void)
Definition: ntv2register.cpp:2491
kRegShiftLTC1InPresent
@ kRegShiftLTC1InPresent
Definition: ntv2publicinterface.h:3030
CNTV2Card::GetRP188SourceFilter
virtual bool GetRP188SourceFilter(const NTV2Channel inSDIInput, UWord &outFilterValue)
Returns the current RP188 filter setting for the given SDI input.
Definition: ntv2register.cpp:2605
NTV2DieTempScale_Rankine
@ NTV2DieTempScale_Rankine
Definition: ntv2enums.h:4193
ULWordSet
std::set< ULWord > ULWordSet
A collection of unique ULWord (uint32_t) values.
Definition: ntv2publicinterface.h:54
kRegVidProc4Control
@ kRegVidProc4Control
Definition: ntv2publicinterface.h:680
kRegFS1ReferenceSelect
@ kRegFS1ReferenceSelect
Definition: ntv2publicinterface.h:219
kRegMaskFrameFormatHiBit
@ kRegMaskFrameFormatHiBit
Definition: ntv2publicinterface.h:1308
CNTV2Card::GetVideoFormat
virtual bool GetVideoFormat(NTV2VideoFormat &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:335
NTV2_FRAMERATE_2398
@ NTV2_FRAMERATE_2398
Fractional rate of 24,000 frames per 1,001 seconds.
Definition: ntv2enums.h:416
kRegMaskSDIInVpidValidB
@ kRegMaskSDIInVpidValidB
Definition: ntv2publicinterface.h:2120
ULWord
uint32_t ULWord
Definition: ajatypes.h:256
kK2RegMaskSDIOutDS1Audio_Bit0
@ kK2RegMaskSDIOutDS1Audio_Bit0
Definition: ntv2publicinterface.h:1683
NTV2_FORMAT_4x4096x2160p_3000
@ NTV2_FORMAT_4x4096x2160p_3000
Definition: ntv2enums.h:703
CNTV2Card::EnableChannels
virtual bool EnableChannels(const NTV2ChannelSet &inChannels, const bool inDisableOthers=(0))
Enables the given FrameStore(s).
Definition: ntv2register.cpp:2171
kK2RegShiftXena2BgVidProcInputControl
@ kK2RegShiftXena2BgVidProcInputControl
Definition: ntv2publicinterface.h:3019
NTV2_RS422_BAUD_RATE_19200
@ NTV2_RS422_BAUD_RATE_19200
19200 baud
Definition: ntv2enums.h:4158
kDeviceGetNumVideoChannels
@ kDeviceGetNumVideoChannels
The number of video channels supported on the device.
Definition: ntv2devicefeatures.h:183
kRegRP188InOut5Bits32_63
@ kRegRP188InOut5Bits32_63
Definition: ntv2publicinterface.h:496
NTV2_FORMAT_2K_2500
@ NTV2_FORMAT_2K_2500
Definition: ntv2enums.h:585
NTV2SetRegisters::mInNumRegisters
ULWord mInNumRegisters
The number of NTV2RegInfo's to be set.
Definition: ntv2publicinterface.h:7801
kRegRP188InOut2DBB
@ kRegRP188InOut2DBB
Definition: ntv2publicinterface.h:185
CNTV2Card::SetAnalogLTCOutClockChannel
virtual bool SetAnalogLTCOutClockChannel(const UWord inLTCOutput, const NTV2Channel inChannel)
Sets the (SDI) output channel that is to provide the clock reference to be used by the given analog L...
Definition: ntv2register.cpp:3840
CNTV2Card::GetSDIWatchdogTimeout
virtual bool GetSDIWatchdogTimeout(ULWord &outValue)
Answers with the amount of time that must elapse before the watchdog timer times out.
Definition: ntv2register.cpp:4189
gChannelToSDIIn3GbModeMask
static const ULWord gChannelToSDIIn3GbModeMask[]
Definition: ntv2register.cpp:94
kRegShift425FB78
@ kRegShift425FB78
Definition: ntv2publicinterface.h:2368
CNTV2Card::GetQuadQuadFrameEnable
virtual bool GetQuadQuadFrameEnable(bool &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device's current "quad-quad" frame mode, whether it's enabled or not.
Definition: ntv2register.cpp:1224
kRegCh6Control2MFrame
@ kRegCh6Control2MFrame
Definition: ntv2publicinterface.h:699
kRegGlobalControlCh6
@ kRegGlobalControlCh6
Definition: ntv2publicinterface.h:549
kRegMaskFrameSizeSetBySW
@ kRegMaskFrameSizeSetBySW
Definition: ntv2publicinterface.h:1326
kLHIRegMaskSDIOut3GbpsMode
@ kLHIRegMaskSDIOut3GbpsMode
Definition: ntv2publicinterface.h:1677
CNTV2Card::GetSDI2OutHTiming
virtual bool GetSDI2OutHTiming(ULWord *value)
Definition: ntv2register.cpp:3401
NTV2_CHANNEL7
@ NTV2_CHANNEL7
Specifies channel or FrameStore 7 (or the 7th item).
Definition: ntv2enums.h:1354
kRegShiftVidProcRGBModeSupported
@ kRegShiftVidProcRGBModeSupported
Definition: ntv2publicinterface.h:2442
CNTV2Card::ReleaseMailBoxLock
virtual bool ReleaseMailBoxLock(void)
Definition: ntv2register.cpp:4545
kRegMaskSDIInTsiMuxSyncFail
@ kRegMaskSDIInTsiMuxSyncFail
Definition: ntv2publicinterface.h:1989
NTV2_FORMAT_4x2048x1080psf_3000
@ NTV2_FORMAT_4x2048x1080psf_3000
Definition: ntv2enums.h:607
CNTV2Card::WriteVirtualData
virtual bool WriteVirtualData(const ULWord inTag, const void *inVirtualData, const ULWord inVirtualDataSize)
Writes the block of virtual data.
Definition: ntv2register.cpp:4693
NTV2_FORMAT_1080p_2997
@ NTV2_FORMAT_1080p_2997
Definition: ntv2enums.h:548
kRegMaskSDIIn73GbpsSMPTELevelBMode
@ kRegMaskSDIIn73GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2024
kRegMaskFrameFormat
@ kRegMaskFrameFormat
Definition: ntv2publicinterface.h:1306
CNTV2Card::GetRunningFirmwareTime
virtual bool GetRunningFirmwareTime(UWord &outHours, UWord &outMinutes, UWord &outSeconds)
Reports the (local Pacific) build time of the currently-running firmware.
Definition: ntv2register.cpp:2407
kRegShift4KDCYCC444Mode
@ kRegShift4KDCYCC444Mode
Definition: ntv2publicinterface.h:3168
kRegRS422Control
@ kRegRS422Control
Definition: ntv2publicinterface.h:193
kRegMRQ1Control
@ kRegMRQ1Control
Definition: ntv2publicinterface.h:1050
NTV2ReferenceSource
NTV2ReferenceSource
These enum values identify a specific source for the device's (output) reference clock.
Definition: ntv2enums.h:1443
NTV2_FORMAT_1080p_2K_4795_B
@ NTV2_FORMAT_1080p_2K_4795_B
Definition: ntv2enums.h:627
kRegCh4InputFrame
@ kRegCh4InputFrame
Definition: ntv2publicinterface.h:403
CNTV2Card::SetLEDState
virtual bool SetLEDState(ULWord inValue)
The four on-board LEDs can be set by writing 0-15.
Definition: ntv2register.cpp:2547
kRegMaskSDIIn46GbpsMode
@ kRegMaskSDIIn46GbpsMode
Definition: ntv2publicinterface.h:2005
kRegShiftInput1GeometryHigh
@ kRegShiftInput1GeometryHigh
Definition: ntv2publicinterface.h:2519
NTV2WidgetType_FrameStore
@ NTV2WidgetType_FrameStore
Definition: ntv2enums.h:3030
kRegShiftMRBypass
@ kRegShiftMRBypass
Definition: ntv2publicinterface.h:3343
CNTV2VPID
A convenience class that simplifies encoding or decoding the 4-byte VPID payload that can be read or ...
Definition: ntv2vpid.h:23
NTV2_FG_720x612
@ NTV2_FG_720x612
720x576, for PAL 625i, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:360
NTV2_FRAMERATE_1498
@ NTV2_FRAMERATE_1498
Fractional rate of 15,000 frames per 1,001 seconds.
Definition: ntv2enums.h:423
kRegRXSDI7Status
@ kRegRXSDI7Status
Definition: ntv2publicinterface.h:774
CNTV2Card::SetMode
virtual bool SetMode(const NTV2Channel inChannel, const NTV2Mode inNewValue, const bool inIsRetail=(!(0)))
Determines if a given FrameStore on the AJA device will be used to capture or playout video.
Definition: ntv2register.cpp:1625
kRegMaskSDIInLocked
@ kRegMaskSDIInLocked
Definition: ntv2publicinterface.h:2118
NTV2_FORMAT_1080p_3000
@ NTV2_FORMAT_1080p_3000
Definition: ntv2enums.h:549
kRegCh4PCIAccessFrame
@ kRegCh4PCIAccessFrame
Definition: ntv2publicinterface.h:431
NTV2_FORMAT_4x3840x2160p_5994
@ NTV2_FORMAT_4x3840x2160p_5994
Definition: ntv2enums.h:692
CNTV2Card::GetSDIOut3GbEnable
virtual bool GetSDIOut3GbEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3942
NTV2_FORMAT_4096x2160p_2398
@ NTV2_FORMAT_4096x2160p_2398
Definition: ntv2enums.h:655
kK2RegShiftFrameSize
@ kK2RegShiftFrameSize
Definition: ntv2publicinterface.h:2410
K2_MAX_V
#define K2_MAX_V
Definition: ntv2register.cpp:49
NTV2Mode
NTV2Mode
Used to identify the mode of a widget_framestore, or the direction of an AutoCirculate stream: either...
Definition: ntv2enums.h:1233
kRegRP188InOut1Bits32_63
@ kRegRP188InOut1Bits32_63
Definition: ntv2publicinterface.h:152
NTV2_FORMAT_720p_6000
@ NTV2_FORMAT_720p_6000
Definition: ntv2enums.h:545
kRegShiftSDIIn3GbpsSMPTELevelBMode
@ kRegShiftSDIIn3GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3041
kDeviceCanDoLTCInOnRefPort
@ kDeviceCanDoLTCInOnRefPort
True if device can read LTC (Linear TimeCode) from its reference input.
Definition: ntv2devicefeatures.h:69
CNTV2Card::GetRunningFirmwarePackageRevision
virtual bool GetRunningFirmwarePackageRevision(ULWord &outRevision)
Reports the revision number of the currently-running firmware package. KonaIP style boards have a pac...
Definition: ntv2register.cpp:2354
NTV2DeviceSoftwareCanChangeFrameBufferSize
bool NTV2DeviceSoftwareCanChangeFrameBufferSize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8814
NTV2_FORMAT_1080p_2500
@ NTV2_FORMAT_1080p_2500
Definition: ntv2enums.h:550
gChannelToSmpte372Shifts
static const ULWord gChannelToSmpte372Shifts[]
Definition: ntv2register.cpp:130
kRegShiftSDIIn7LevelBtoLevelA
@ kRegShiftSDIIn7LevelBtoLevelA
Definition: ntv2publicinterface.h:3089
kRegShiftSDIInLocked
@ kRegShiftSDIInLocked
Definition: ntv2publicinterface.h:3180
kRegCh2InputFrame
@ kRegCh2InputFrame
Definition: ntv2publicinterface.h:128
ntv2card.h
Declares the CNTV2Card class.
CNTV2Card::SetForce64
virtual bool SetForce64(ULWord force64)
Definition: ntv2register.cpp:3251
CNTV2Card::SetSDIOutRGBLevelAConversion
virtual bool SetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, const bool inEnable)
Enables or disables an RGB-over-3G-level-A conversion at the SDI output widget (assuming the AJA devi...
Definition: ntv2register.cpp:4397
gChannelToSDIInputRateHighMask
static const ULWord gChannelToSDIInputRateHighMask[]
Definition: ntv2register.cpp:154
kRegShiftSDIWatchdogStatus
@ kRegShiftSDIWatchdogStatus
Definition: ntv2publicinterface.h:3162
NTV2MixerInputControlToString
std::string NTV2MixerInputControlToString(const NTV2MixerKeyerInputControl inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6424
NTV2_FORMAT_3840x2160psf_3000
@ NTV2_FORMAT_3840x2160psf_3000
Definition: ntv2enums.h:643
CNTV2Card::GetEncodeAsPSF
virtual bool GetEncodeAsPSF(NTV2Channel inChannel, NTV2EncodeAsPSF &outValue)
Definition: ntv2register.cpp:2021
gChannelToRXSDICRCErrorCountRegs
static const ULWord gChannelToRXSDICRCErrorCountRegs[]
Definition: ntv2register.cpp:124
NTV2_FRAMESIZE_4MB
@ NTV2_FRAMESIZE_4MB
Definition: ntv2enums.h:2108
kRegShiftVidProcVANCShift
@ kRegShiftVidProcVANCShift
Definition: ntv2publicinterface.h:2419
kDeviceGetHDMIVersion
@ kDeviceGetHDMIVersion
The version number of the HDMI chipset on the device.
Definition: ntv2devicefeatures.h:177
CNTV2Card::SetAnalogLTCInClockChannel
virtual bool SetAnalogLTCInClockChannel(const UWord inLTCInput, const NTV2Channel inChannel)
Sets the (SDI) input channel that is to provide the clock reference to be used by the given analog LT...
Definition: ntv2register.cpp:3795
kRegCh5PCIAccessFrame
@ kRegCh5PCIAccessFrame
Definition: ntv2publicinterface.h:556
kRegMaskFrameRateHiBit
@ kRegMaskFrameRateHiBit
Definition: ntv2publicinterface.h:1236
kRegMaskDualLinkInEnable
@ kRegMaskDualLinkInEnable
Definition: ntv2publicinterface.h:1244
kRegShiftSDIRelayPosition12
@ kRegShiftSDIRelayPosition12
Definition: ntv2publicinterface.h:3160
NTV2_INPUTSOURCE_SDI5
@ NTV2_INPUTSOURCE_SDI5
Identifies the 5th SDI video input.
Definition: ntv2enums.h:1267
kRegShiftSDIIn412GbpsMode
@ kRegShiftSDIIn412GbpsMode
Definition: ntv2publicinterface.h:3070
CNTV2Card::GetEnable4KDCRGBMode
virtual bool GetEnable4KDCRGBMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4207
NTV2_FRAMESIZE_30MB
@ NTV2_FRAMESIZE_30MB
Definition: ntv2enums.h:2121
CNTV2Card::SetMixerMatteColor
virtual bool SetMixerMatteColor(const UWord inWhichMixer, const YCbCr10BitPixel inYCbCrValue)
Sets the matte color to use for the given mixer/keyer.
Definition: ntv2register.cpp:3085
CNTV2Card::GetAnalogLTCOutClockChannel
virtual bool GetAnalogLTCOutClockChannel(const UWord inLTCOutput, NTV2Channel &outChannel)
Answers with the (SDI) output channel that's providing the clock reference being used by the given de...
Definition: ntv2register.cpp:3822
kVRegVideoFormatCh1
@ kVRegVideoFormatCh1
Definition: ntv2virtualregisters.h:347
CNTV2Card::SetRP188BypassSource
virtual bool SetRP188BypassSource(const NTV2Channel inSDIOutput, const UWord inSDIInput)
For the given SDI output that's in RP188 bypass mode (E-E), specifies the SDI input to be used as a t...
Definition: ntv2register.cpp:2645
kRegMaskVidProcVANCShift
@ kRegMaskVidProcVANCShift
Definition: ntv2publicinterface.h:1327
NTV2_FORMAT_4x2048x1080p_5000
@ NTV2_FORMAT_4x2048x1080p_5000
Definition: ntv2enums.h:611
kRegGlobalControl2
@ kRegGlobalControl2
Definition: ntv2publicinterface.h:408
NTV2StandardToString
std::string NTV2StandardToString(const NTV2Standard inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6802
NTV2InputCrosspointIDToString
std::string NTV2InputCrosspointIDToString(const NTV2InputCrosspointID inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5714
kK2RegMaskSDIOutDS1Audio_Bit2
@ kK2RegMaskSDIOutDS1Audio_Bit2
Definition: ntv2publicinterface.h:1681
CNTV2Card::GetSDIOutputAudioSystem
virtual bool GetSDIOutputAudioSystem(const NTV2Channel inSDIOutputConnector, NTV2AudioSystem &outAudioSystem)
Answers with the device's NTV2AudioSystem that is currently providing audio for the given SDI output'...
Definition: ntv2register.cpp:3993
CNTV2Card::GetNTV2VideoFormat
static NTV2VideoFormat GetNTV2VideoFormat(NTV2FrameRate frameRate, UByte inputGeometry, bool progressiveTransport, bool isThreeG, bool progressivePicture=(0))
Definition: ntv2register.cpp:371
kRegShiftSDI2Transmit
@ kRegShiftSDI2Transmit
Definition: ntv2publicinterface.h:3151
kRegShiftSDIIn73GbpsMode
@ kRegShiftSDIIn73GbpsMode
Definition: ntv2publicinterface.h:3087
gChannelToSDIInputGeometryHighMask
static const ULWord gChannelToSDIInputGeometryHighMask[]
Definition: ntv2register.cpp:163
CNTV2Card::SetFramePulseReference
virtual bool SetFramePulseReference(const NTV2ReferenceSource inRefSource)
Sets the device's frame pulse reference source. See Video Output Clocking & Synchronization for more ...
Definition: ntv2register.cpp:1604
kRegMaskInput1FrameRateHigh
@ kRegMaskInput1FrameRateHigh
Definition: ntv2publicinterface.h:1425
NTV2_FORMAT_4096x2160p_6000
@ NTV2_FORMAT_4096x2160p_6000
Definition: ntv2enums.h:666
SAREK_REGS
#define SAREK_REGS
Definition: ntv2registersmb.h:54
NTV2_REFERENCE_INPUT6
@ NTV2_REFERENCE_INPUT6
Specifies the SDI In 6 connector.
Definition: ntv2enums.h:1454
NTV2_FG_720x514
@ NTV2_FG_720x514
720x486, for NTSC 525i and 525p60, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:359
NTV2_FRAMESIZE_20MB
@ NTV2_FRAMESIZE_20MB
Definition: ntv2enums.h:2116
kRegMaskSDIIn23GbpsSMPTELevelBMode
@ kRegMaskSDIIn23GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:1983
gChannelToSDIInputRateHighShift
static const ULWord gChannelToSDIInputRateHighShift[]
Definition: ntv2register.cpp:158
kRegShiftMRFrameLocation
@ kRegShiftMRFrameLocation
Definition: ntv2publicinterface.h:3342
kRegGlobalControl3
@ kRegGlobalControl3
Definition: ntv2publicinterface.h:234
CNTV2Card::SetVideoHOffset
virtual bool SetVideoHOffset(const int inHOffset, const UWord inOutputSpigot=0)
Adjusts the horizontal timing offset, in pixels, for the given SDI output connector.
Definition: ntv2register.cpp:616
kRegRXSDI1CRCErrorCount
@ kRegRXSDI1CRCErrorCount
Definition: ntv2publicinterface.h:721
CNTV2Card::SetLTCInputEnable
virtual bool SetLTCInputEnable(const bool inEnable)
Enables or disables the ability for the device to read analog LTC on the reference input connector.
Definition: ntv2register.cpp:3715
NTV2_THROUGH_DEVICE
@ NTV2_THROUGH_DEVICE
Input & output routed through device.
Definition: ntv2enums.h:3917
NTV2_HEADER
All new NTV2 structs start with this common header.
Definition: ntv2publicinterface.h:7192
kRegShiftVidProcLimiting
@ kRegShiftVidProcLimiting
Definition: ntv2publicinterface.h:2434
NTV2_CHANNEL3
@ NTV2_CHANNEL3
Specifies channel or FrameStore 3 (or the 3rd item).
Definition: ntv2enums.h:1350
kRegMaskRGBLevelA
@ kRegMaskRGBLevelA
Definition: ntv2publicinterface.h:1675
kRegShiftSDIIn76GbpsMode
@ kRegShiftSDIIn76GbpsMode
Definition: ntv2publicinterface.h:3092
CNTV2Card::GetLEDState
virtual bool GetLEDState(ULWord &outValue)
Answers with the current state of the four on-board LEDs.
Definition: ntv2register.cpp:2548
kRegMaskSmpte372Enable4
@ kRegMaskSmpte372Enable4
Definition: ntv2publicinterface.h:1265
kRegCh3Control2MFrame
@ kRegCh3Control2MFrame
Definition: ntv2publicinterface.h:696
NTV2_STANDARD_1080p
@ NTV2_STANDARD_1080p
Identifies SMPTE HD 1080p.
Definition: ntv2enums.h:165
kRegRP188InOut7Bits0_31
@ kRegRP188InOut7Bits0_31
Definition: ntv2publicinterface.h:601
UWord
uint16_t UWord
Definition: ajatypes.h:254
kK2RegMaskXena2FgVidProcInputControl
@ kK2RegMaskXena2FgVidProcInputControl
Definition: ntv2publicinterface.h:1955
kRegShift4KDCRGBMode
@ kRegShift4KDCRGBMode
Definition: ntv2publicinterface.h:3167
NTV2RegisterReads
NTV2RegWrites NTV2RegisterReads
Definition: ntv2publicinterface.h:4141
NTV2VANCModeToString
std::string NTV2VANCModeToString(const NTV2VANCMode inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6397
kRegShiftChannelDisable
@ kRegShiftChannelDisable
Definition: ntv2publicinterface.h:2400
kRegSDIOut5Control
@ kRegSDIOut5Control
Definition: ntv2publicinterface.h:491
NTV2_FORMAT_4x1920x1080p_3000
@ NTV2_FORMAT_4x1920x1080p_3000
Definition: ntv2enums.h:601
kRegShift425FB34
@ kRegShift425FB34
Definition: ntv2publicinterface.h:2366
NTV2_FRAMESIZE_12MB
@ NTV2_FRAMESIZE_12MB
Definition: ntv2enums.h:2113
kRegShiftRegClocking
@ kRegShiftRegClocking
Definition: ntv2publicinterface.h:2336
NTV2_IS_VANCMODE_ON
#define NTV2_IS_VANCMODE_ON(__v__)
Definition: ntv2enums.h:3786
NTV2_FORMAT_4x3840x2160p_2997
@ NTV2_FORMAT_4x3840x2160p_2997
Definition: ntv2enums.h:689
NTV2_FBF_8BIT_YCBCR
@ NTV2_FBF_8BIT_YCBCR
See 8-Bit YCbCr Format.
Definition: ntv2enums.h:217
NTV2_REFERENCE_FREERUN
@ NTV2_REFERENCE_FREERUN
Specifies the device's internal clock.
Definition: ntv2enums.h:1448
kRegMaskMRStandard
@ kRegMaskMRStandard
Definition: ntv2publicinterface.h:2280
kRegShiftInput2Progressive
@ kRegShiftInput2Progressive
Definition: ntv2publicinterface.h:2509
NTV2MIXERINPUTCONTROL_INVALID
@ NTV2MIXERINPUTCONTROL_INVALID
Definition: ntv2enums.h:1770
kRegMaskStandard
@ kRegMaskStandard
Definition: ntv2publicinterface.h:1238
ntv2utils.h
Declares numerous NTV2 utility functions.
kRegInputStatus2
@ kRegInputStatus2
Definition: ntv2publicinterface.h:429
gChannelToRP188ModeMasks
static const ULWord gChannelToRP188ModeMasks[]
Definition: ntv2register.cpp:111
CNTV2Card::SetSDI2OutHTiming
virtual bool SetSDI2OutHTiming(ULWord value)
Definition: ntv2register.cpp:3400
kRegOutputTimingControlch8
@ kRegOutputTimingControlch8
Definition: ntv2publicinterface.h:674
kRegShiftSDIIn86GbpsMode
@ kRegShiftSDIIn86GbpsMode
Definition: ntv2publicinterface.h:3099
NTV2_FORMAT_1080p_5000_B
@ NTV2_FORMAT_1080p_5000_B
Definition: ntv2enums.h:558
kRegMaskSDIIn812GbpsMode
@ kRegMaskSDIIn812GbpsMode
Definition: ntv2publicinterface.h:2036
NTV2Framesize
NTV2Framesize
Kona2/Xena2 specific enums.
Definition: ntv2enums.h:2105
CNTV2Card::GetAnalogCompositeInputVideoFormat
virtual NTV2VideoFormat GetAnalogCompositeInputVideoFormat(void)
Returns the video format of the signal that is present on the device's composite video input.
Definition: ntv2register.cpp:3577
NTV2_FRAMESIZE_10MB
@ NTV2_FRAMESIZE_10MB
Definition: ntv2enums.h:2112
kRegMaskSDIIn3LevelBtoLevelA
@ kRegMaskSDIIn3LevelBtoLevelA
Definition: ntv2publicinterface.h:1995
kRegShiftQuadMode
@ kRegShiftQuadMode
Definition: ntv2publicinterface.h:2348
Get4xSizedGeometry
NTV2FrameGeometry Get4xSizedGeometry(const NTV2FrameGeometry inGeometry)
Definition: ntv2utils.cpp:2232
NTV2_RS422_ODD_PARITY
@ NTV2_RS422_ODD_PARITY
Odd parity – this is the power-up default.
Definition: ntv2enums.h:4143
K2_MIN_H
#define K2_MIN_H
Definition: ntv2register.cpp:45
CNTV2Card::GetDefaultVideoOutMode
virtual bool GetDefaultVideoOutMode(ULWord &outMode)
Definition: ntv2register.cpp:195
CNTV2Card::GetSDIUnlockCount
virtual ULWord GetSDIUnlockCount(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4277
NTV2_FORMAT_4x3840x2160p_5000
@ NTV2_FORMAT_4x3840x2160p_5000
Definition: ntv2enums.h:691
kK2RegShiftXena2FgVidProcInputControl
@ kK2RegShiftXena2FgVidProcInputControl
Definition: ntv2publicinterface.h:3018
NTV2_FORMAT_1080p_2K_5994_A
@ NTV2_FORMAT_1080p_2K_5994_A
Definition: ntv2enums.h:621
kRegInput56Status
@ kRegInput56Status
Definition: ntv2publicinterface.h:643
kRegMaskFramePulseRefSelect
@ kRegMaskFramePulseRefSelect
Definition: ntv2publicinterface.h:1292
kRegMask425FB78
@ kRegMask425FB78
Definition: ntv2publicinterface.h:1275
kRegMaskSDIIn1LevelBtoLevelA
@ kRegMaskSDIIn1LevelBtoLevelA
Definition: ntv2publicinterface.h:1977
kRegShiftSDIIn812GbpsMode
@ kRegShiftSDIIn812GbpsMode
Definition: ntv2publicinterface.h:3100
CNTV2Card::GetSDIOutLevelAtoLevelBConversion
virtual bool GetSDIOutLevelAtoLevelBConversion(const UWord inOutputSpigot, bool &outIsEnabled)
Answers with the device's current 3G level A to 3G level B conversion setting for the given SDI outpu...
Definition: ntv2register.cpp:4384
kRegShiftSDIIn56GbpsMode
@ kRegShiftSDIIn56GbpsMode
Definition: ntv2publicinterface.h:3078
kRegMaskSDIWatchdogEnable34
@ kRegMaskSDIWatchdogEnable34
Definition: ntv2publicinterface.h:2099
kRegMaskSDIIn36GbpsMode
@ kRegMaskSDIIn36GbpsMode
Definition: ntv2publicinterface.h:1998
kRegShiftRefSource
@ kRegShiftRefSource
Definition: ntv2publicinterface.h:2332
gChannelToPCIAccessFrameRegNum
static const ULWord gChannelToPCIAccessFrameRegNum[]
Definition: ntv2register.cpp:83
kVRegPCIDeviceID
@ kVRegPCIDeviceID
Definition: ntv2virtualregisters.h:305
CNTV2Card
I interrogate and control an AJA video/audio capture/playout device.
Definition: ntv2card.h:28
NTV2_FORMAT_4x2048x1080p_12000
@ NTV2_FORMAT_4x2048x1080p_12000
Definition: ntv2enums.h:617
kRegBitfileDate
@ kRegBitfileDate
Definition: ntv2publicinterface.h:211
NTV2BankSelGetSetRegs::GetRegInfo
NTV2RegInfo GetRegInfo(const UWord inIndex0=0) const
Definition: ntv2publicinterface.cpp:3692
SSC_GET_FIRMWARE_PROGRESS_STRUCT::programState
ProgramState programState
Definition: ntv2publicinterface.h:5070
kRegMaskRP188ModeCh7
@ kRegMaskRP188ModeCh7
Definition: ntv2publicinterface.h:1280
gChannelToSDIInputGeometryShift
static const ULWord gChannelToSDIInputGeometryShift[]
Definition: ntv2register.cpp:165
kRegMaskSDIIn512GbpsMode
@ kRegMaskSDIIn512GbpsMode
Definition: ntv2publicinterface.h:2015
NTV2OutputXptIDSet
std::set< NTV2OutputXptID > NTV2OutputXptIDSet
A collection of distinct NTV2OutputXptID values.
Definition: ntv2signalrouter.h:18
gIndexToVidProcMixCoeffRegNum
static const ULWord gIndexToVidProcMixCoeffRegNum[]
Definition: ntv2register.cpp:102
kRegMask425FB34
@ kRegMask425FB34
Definition: ntv2publicinterface.h:1273
gChannelToRP188ModeShifts
static const ULWord gChannelToRP188ModeShifts[]
Definition: ntv2register.cpp:113
kRegMaskMREnable
@ kRegMaskMREnable
Definition: ntv2publicinterface.h:2283
CNTV2Card::GetVANCShiftMode
virtual bool GetVANCShiftMode(NTV2Channel inChannel, NTV2VANCDataShiftMode &outValue)
Retrieves the current "VANC Shift Mode" feature for the given channel.
Definition: ntv2register.cpp:2885
NTV2DieTempScale_Celsius
@ NTV2DieTempScale_Celsius
Definition: ntv2enums.h:4190
kRegMaskQuadQuadMode2
@ kRegMaskQuadQuadMode2
Definition: ntv2publicinterface.h:1288
kRegMaskRefSource2
@ kRegMaskRefSource2
Definition: ntv2publicinterface.h:1253
NTV2_REFERENCE_HDMI_INPUT1
@ NTV2_REFERENCE_HDMI_INPUT1
Specifies the HDMI In 1 connector.
Definition: ntv2enums.h:1450
kRegMaskMode
@ kRegMaskMode
Definition: ntv2publicinterface.h:1305
NTV2ULWordVector
std::vector< ULWord > NTV2ULWordVector
An ordered sequence of ULWords.
Definition: ntv2publicinterface.h:3909
NTV2WidgetType_SDIIn
@ NTV2WidgetType_SDIIn
Definition: ntv2enums.h:3034
NTV2_FORMAT_625psf_2500
@ NTV2_FORMAT_625psf_2500
Definition: ntv2enums.h:578
kRegMaskSDIRelayControl12
@ kRegMaskSDIRelayControl12
Definition: ntv2publicinterface.h:2096
NTV2WidgetID
NTV2WidgetID
Definition: ntv2enums.h:2898
kRegShiftSDIIn23GbpsSMPTELevelBMode
@ kRegShiftSDIIn23GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3048
NTV2_INPUTSOURCE_HDMI4
@ NTV2_INPUTSOURCE_HDMI4
Identifies the 4th HDMI video input.
Definition: ntv2enums.h:1262
NTV2DeviceIsDirectAddressable
bool NTV2DeviceIsDirectAddressable(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8443
kRegMaskSDIIn5LevelBtoLevelA
@ kRegMaskSDIIn5LevelBtoLevelA
Definition: ntv2publicinterface.h:2011
retVal
else retVal
Definition: ntv2vcam.cpp:1100
kRegRXSDI6CRCErrorCount
@ kRegRXSDI6CRCErrorCount
Definition: ntv2publicinterface.h:766
kRegShiftSDIIn8LevelBtoLevelA
@ kRegShiftSDIIn8LevelBtoLevelA
Definition: ntv2publicinterface.h:3096
NTV2_FG_1280x720
@ NTV2_FG_1280x720
1280x720, for 720p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:346
RP188_STRUCT
Definition: ntv2publicinterface.h:4210
kRegShiftSDIIn33GbpsSMPTELevelBMode
@ kRegShiftSDIIn33GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3058
kRegXenaxFlashDOUT
@ kRegXenaxFlashDOUT
Definition: ntv2publicinterface.h:182
kK2RegMaskSDI1Out_2Kx1080Mode
@ kK2RegMaskSDI1Out_2Kx1080Mode
Definition: ntv2publicinterface.h:1669
NTV2_FORMAT_1080p_2K_2500
@ NTV2_FORMAT_1080p_2K_2500
Definition: ntv2enums.h:566
kRegShiftEncodeAsPSF
@ kRegShiftEncodeAsPSF
Definition: ntv2publicinterface.h:2409
kRegMaskMRBypass
@ kRegMaskMRBypass
Definition: ntv2publicinterface.h:2282
NTV2_FORMAT_4x1920x1080psf_2997
@ NTV2_FORMAT_4x1920x1080psf_2997
Definition: ntv2enums.h:602
NTV2_RP188::fDBB
ULWord fDBB
Definition: ntv2publicinterface.h:6999
NTV2ChannelSet
std::set< NTV2Channel > NTV2ChannelSet
A set of distinct NTV2Channel values.
Definition: ntv2publicinterface.h:3938
CNTV2Card::GetSecondaryVideoFormat
virtual bool GetSecondaryVideoFormat(NTV2VideoFormat &outFormat)
Definition: ntv2register.cpp:3408
kRegDMAControl
@ kRegDMAControl
Definition: ntv2publicinterface.h:169
NTV2HDRColorimetry
enum NTV2VPIDColorimetry NTV2HDRColorimetry
kRegSDIOut7Control
@ kRegSDIOut7Control
Definition: ntv2publicinterface.h:665
CNTV2Card::SetTsiFrameEnable
virtual bool SetTsiFrameEnable(const bool inIsEnabled, const NTV2Channel inChannel)
Enables or disables SMPTE 425 two-sample interleave (Tsi) frame mode on the device.
Definition: ntv2register.cpp:1311
kRegOutputTimingControlch4
@ kRegOutputTimingControlch4
Definition: ntv2publicinterface.h:670
NTV2_FORMAT_1080p_6000_A
@ NTV2_FORMAT_1080p_6000_A
Definition: ntv2enums.h:565
NTV2_FORMAT_3840x2160psf_2398
@ NTV2_FORMAT_3840x2160psf_2398
Definition: ntv2enums.h:634
NTV2_INPUTSOURCE_HDMI1
@ NTV2_INPUTSOURCE_HDMI1
Identifies the 1st HDMI video input.
Definition: ntv2enums.h:1259
kRegMaskSDIInTRSError
@ kRegMaskSDIInTRSError
Definition: ntv2publicinterface.h:2121
CNTV2Card::GetReference
virtual bool GetReference(NTV2ReferenceSource &outRefSource)
Answers with the device's current clock reference source.
Definition: ntv2register.cpp:1523
kVRegMailBoxAcquire
@ kVRegMailBoxAcquire
Definition: ntv2virtualregisters.h:413
kRegSDIWatchdogControlStatus
@ kRegSDIWatchdogControlStatus
Definition: ntv2publicinterface.h:457
kRegMaskSDI4Transmit
@ kRegMaskSDI4Transmit
Definition: ntv2publicinterface.h:2093
kRegMaskSDIInCRCErrorCountA
@ kRegMaskSDIInCRCErrorCountA
Definition: ntv2publicinterface.h:2123
kRegMaskSDIInVpidValidA
@ kRegMaskSDIInVpidValidA
Definition: ntv2publicinterface.h:2119
CNTV2Card::GetSDIInputRate
virtual NTV2FrameRate GetSDIInputRate(const NTV2Channel channel)
Definition: ntv2register.cpp:3622
CNTV2Card::GetInputVideoFormat
virtual NTV2VideoFormat GetInputVideoFormat(const NTV2InputSource inVideoSource=NTV2_INPUTSOURCE_SDI1, const bool inIsProgressive=(0))
Returns the video format of the signal that is present on the given input source.
Definition: ntv2register.cpp:3429
CNTV2Card::SetDitherFor8BitInputs
virtual bool SetDitherFor8BitInputs(const NTV2Channel inChannel, const ULWord inDither)
Definition: ntv2register.cpp:3235
NTV2_STANDARD_TASKS
@ NTV2_STANDARD_TASKS
1: Standard/Retail: device configured by AJA ControlPanel, service/daemon, and driver.
Definition: ntv2publicinterface.h:4465
kRegShiftAnalogInputIntegerRate
@ kRegShiftAnalogInputIntegerRate
Definition: ntv2publicinterface.h:2669
NTV2_FRAMERATE_11988
@ NTV2_FRAMERATE_11988
Fractional rate of 120,000 frames per 1,001 seconds.
Definition: ntv2enums.h:421
gChannelToRXSDIStatusRegs
static const ULWord gChannelToRXSDIStatusRegs[]
Definition: ntv2register.cpp:122
kNTV2EnumsID_WidgetID
@ kNTV2EnumsID_WidgetID
Identifies the NTV2AudioWidgetID enumerated type.
Definition: ntv2devicefeatures.h:254
NTV2SetRegisters::mInRegInfos
NTV2Buffer mInRegInfos
Read-only array of NTV2RegInfo structs to be set. The SDK owns this memory.
Definition: ntv2publicinterface.h:7802
kRegMaskSDIIn2LevelBtoLevelA
@ kRegMaskSDIIn2LevelBtoLevelA
Definition: ntv2publicinterface.h:1984
NTV2QuarterSizeExpandMode
NTV2QuarterSizeExpandMode
Definition: ntv2enums.h:2475
NTV2_FORMAT_1080p_2K_2398
@ NTV2_FORMAT_1080p_2K_2398
Definition: ntv2enums.h:553
gChannelToSDIIn3GbModeShift
static const ULWord gChannelToSDIIn3GbModeShift[]
Definition: ntv2register.cpp:97
kRegRP188InOut1DBB
@ kRegRP188InOut1DBB
Definition: ntv2publicinterface.h:150
kRegMaskSDIIn33GbpsMode
@ kRegMaskSDIIn33GbpsMode
Definition: ntv2publicinterface.h:1993
NTV2_FORMAT_3840x2160p_2997
@ NTV2_FORMAT_3840x2160p_2997
Definition: ntv2enums.h:640
CNTV2Card::SetEveryFrameServices
virtual bool SetEveryFrameServices(const NTV2EveryFrameTaskMode inMode)
Sets the device's task mode.
Definition: ntv2register.cpp:179
NTV2_FORMAT_4096x2160p_4800
@ NTV2_FORMAT_4096x2160p_4800
Definition: ntv2enums.h:663
kRegShiftRS422BaudRate
@ kRegShiftRS422BaudRate
Definition: ntv2publicinterface.h:2590
CNTV2SignalRouter::WidgetIDFromTypeAndChannel
static NTV2WidgetID WidgetIDFromTypeAndChannel(const NTV2WidgetType inWidgetType, const NTV2Channel inChannel)
Definition: ntv2signalrouter.cpp:551
kRegFlatMatte3Value
@ kRegFlatMatte3Value
Definition: ntv2publicinterface.h:678
kRegShiftFrameSizeSetBySW
@ kRegShiftFrameSizeSetBySW
Definition: ntv2publicinterface.h:2418
NTV2_FORMAT_1080p_2398
@ NTV2_FORMAT_1080p_2398
Definition: ntv2enums.h:551
kRegShiftSmpte372
@ kRegShiftSmpte372
Definition: ntv2publicinterface.h:2334
kRegShiftStandard
@ kRegShiftStandard
Definition: ntv2publicinterface.h:2331
NTV2VANCMode
NTV2VANCMode
These enum values identify the available VANC modes.
Definition: ntv2enums.h:3775
AJA_DebugUnit_UserGeneric
@ AJA_DebugUnit_UserGeneric
Definition: debugshare.h:50
CNTV2Card::SetSDIWatchdogTimeout
virtual bool SetSDIWatchdogTimeout(const ULWord inValue)
Specifies the amount of time that must elapse before the watchdog timer times out.
Definition: ntv2register.cpp:4197
kRegSDIOut2Control
@ kRegSDIOut2Control
Definition: ntv2publicinterface.h:264
NTV2_STANDARD_4096i
@ NTV2_STANDARD_4096i
Identifies 4K psf.
Definition: ntv2enums.h:176
CNTV2Card::GetMode
virtual bool GetMode(const NTV2Channel inChannel, NTV2Mode &outValue)
Answers with the current NTV2Mode of the given FrameStore on the AJA device.
Definition: ntv2register.cpp:1643
NTV2_FORMAT_3840x2160psf_2400
@ NTV2_FORMAT_3840x2160psf_2400
Definition: ntv2enums.h:635
kK2RegMaskSDIOutDS2Audio_Bit1
@ kK2RegMaskSDIOutDS2Audio_Bit1
Definition: ntv2publicinterface.h:1685
NTV2_FORMAT_1080psf_2K_2400
@ NTV2_FORMAT_1080psf_2K_2400
Definition: ntv2enums.h:556
kRegMaskQuality
@ kRegMaskQuality
Definition: ntv2publicinterface.h:1317
kK2RegShiftOutHTiming
@ kK2RegShiftOutHTiming
Definition: ntv2publicinterface.h:2750
NTV2_IS_PSF_VIDEO_FORMAT
#define NTV2_IS_PSF_VIDEO_FORMAT(__f__)
Definition: ntv2enums.h:1010
NTV2_IS_VALID_CHANNEL
#define NTV2_IS_VALID_CHANNEL(__x__)
Definition: ntv2enums.h:1360
NTV2RegInfo::registerValue
ULWord registerValue
My register value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4048
CNTV2Card::GetCRCErrorCountB
virtual ULWord GetCRCErrorCountB(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4299
kRegShiftSDIIn512GbpsMode
@ kRegShiftSDIIn512GbpsMode
Definition: ntv2publicinterface.h:3079
kRegFlashProgramReg
@ kRegFlashProgramReg
Definition: ntv2publicinterface.h:137
NTV2MixerKeyerModeToString
std::string NTV2MixerKeyerModeToString(const NTV2MixerKeyerMode inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6410
kRegMaskInput2Geometry
@ kRegMaskInput2Geometry
Definition: ntv2publicinterface.h:1416
NTV2_VANCMODE_INVALID
@ NTV2_VANCMODE_INVALID
This identifies the invalid (unspecified, uninitialized) VANC mode.
Definition: ntv2enums.h:3780
NTV2_FORMAT_3840x2160p_5994
@ NTV2_FORMAT_3840x2160p_5994
Definition: ntv2enums.h:645
kRegMask4KDCPSFOutMode
@ kRegMask4KDCPSFOutMode
Definition: ntv2publicinterface.h:2108
kRegShiftSDIIn26GbpsMode
@ kRegShiftSDIIn26GbpsMode
Definition: ntv2publicinterface.h:3052
CNTV2Card::SetMixerFGInputControl
virtual bool SetMixerFGInputControl(const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
Sets the foreground input control value for the given mixer/keyer.
Definition: ntv2register.cpp:2938
NTV2_FORMAT_4x4096x2160p_2400
@ NTV2_FORMAT_4x4096x2160p_2400
Definition: ntv2enums.h:700
NTV2BankSelGetSetRegs::mInRegInfos
NTV2Buffer mInRegInfos
NTV2RegInfo array of registers be read/written. The SDK owns this memory.
Definition: ntv2publicinterface.h:7866
kRegCh3OutputFrame
@ kRegCh3OutputFrame
Definition: ntv2publicinterface.h:399
kRegMaskRP188ModeCh6
@ kRegMaskRP188ModeCh6
Definition: ntv2publicinterface.h:1279
ProgramState
ProgramState
Definition: ntv2publicinterface.h:5035
kRegShiftVidProcVancSource
@ kRegShiftVidProcVancSource
Definition: ntv2publicinterface.h:2435
NTV2DieTempScale_Fahrenheit
@ NTV2DieTempScale_Fahrenheit
Definition: ntv2enums.h:4191
CNTV2Card::Get64BitAutodetect
virtual bool Get64BitAutodetect(ULWord *autodetect64)
Definition: ntv2register.cpp:3253
kRegMRQ4Control
@ kRegMRQ4Control
Definition: ntv2publicinterface.h:1053
NTV2_INPUTSOURCE_HDMI2
@ NTV2_INPUTSOURCE_HDMI2
Identifies the 2nd HDMI video input.
Definition: ntv2enums.h:1260
NTV2_FORMAT_4x4096x2160p_6000
@ NTV2_FORMAT_4x4096x2160p_6000
Definition: ntv2enums.h:708
kRegMaskSDI3Transmit
@ kRegMaskSDI3Transmit
Definition: ntv2publicinterface.h:2092
NTV2_FORMAT_3840x2160p_2398
@ NTV2_FORMAT_3840x2160p_2398
Definition: ntv2enums.h:637
NTV2_FG_1920x1112
@ NTV2_FG_1920x1112
1920x1080, for 1080i and 1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:353
kRegSDIOut6Control
@ kRegSDIOut6Control
Definition: ntv2publicinterface.h:664
NTV2InputSource
NTV2InputSource
Identifies a specific video input source.
Definition: ntv2enums.h:1256
NTV2SDIInputStatus::mFrameRefClockCount
ULWord64 mFrameRefClockCount
This count is incremented on each 148.xx reference clock, and latched at EAV for each frame.
Definition: ntv2publicinterface.h:7111
kRegStatus
@ kRegStatus
Definition: ntv2publicinterface.h:142
kRegMaskSDIIn56GbpsMode
@ kRegMaskSDIIn56GbpsMode
Definition: ntv2publicinterface.h:2014
CNTV2Card::GetEnableFramePulseReference
virtual bool GetEnableFramePulseReference(bool &outEnabled)
Answers whether or not the device's current frame pulse reference source is enabled....
Definition: ntv2register.cpp:1593
kRegCh7PCIAccessFrame
@ kRegCh7PCIAccessFrame
Definition: ntv2publicinterface.h:566
CNTV2Card::GetMultiRasterBypassEnable
virtual bool GetMultiRasterBypassEnable(bool &outEnabled)
Definition: ntv2register.cpp:4758
CNTV2Card::GetMixerVancOutputFromForeground
virtual bool GetMixerVancOutputFromForeground(const UWord inWhichMixer, bool &outIsFromForegroundSource)
Answers whether or not the VANC source for the given mixer/keyer is currently the foreground video....
Definition: ntv2register.cpp:2926
kRegVidProc1Control
@ kRegVidProc1Control
Definition: ntv2publicinterface.h:129
kRegMaskSDIInCRCErrorCountB
@ kRegMaskSDIInCRCErrorCountB
Definition: ntv2publicinterface.h:2124
kFS1RefMaskLTCEmbeddedOutEnable
@ kFS1RefMaskLTCEmbeddedOutEnable
Definition: ntv2publicinterface.h:1546
CNTV2Card::GetFrameGeometry
virtual bool GetFrameGeometry(NTV2FrameGeometry &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:970
kRegMaskSmpte372Enable6
@ kRegMaskSmpte372Enable6
Definition: ntv2publicinterface.h:1266
kRegSDI5678Input3GStatus
@ kRegSDI5678Input3GStatus
Definition: ntv2publicinterface.h:641
NTV2_FORMAT_UNKNOWN
@ NTV2_FORMAT_UNKNOWN
Definition: ntv2enums.h:528
kRegMask2MFrameSupport
@ kRegMask2MFrameSupport
Definition: ntv2publicinterface.h:1269
gChannelToOutputFrameRegNum
static const ULWord gChannelToOutputFrameRegNum[]
Definition: ntv2register.cpp:77
CNTV2Card::ReadOutputTimingControl
virtual bool ReadOutputTimingControl(ULWord &outValue, const UWord inOutputSpigot=0)
Returns the current output timing control value for the given SDI output connector.
Definition: ntv2register.cpp:3388
kVRegInputSelect
@ kVRegInputSelect
Definition: ntv2virtualregisters.h:42
kRegCPLDVersion
@ kRegCPLDVersion
Definition: ntv2publicinterface.h:184
kRegOutputTimingControlch2
@ kRegOutputTimingControlch2
Definition: ntv2publicinterface.h:668
kK2RegMaskOutHTiming
@ kK2RegMaskOutHTiming
Definition: ntv2publicinterface.h:1665
NTV2SDIInputStatus::mCRCTallyB
UWord mCRCTallyB
The number of lines having a CRC error was detected in the "A" stream of the SDI link since this tall...
Definition: ntv2publicinterface.h:7107
NTV2_IS_QUAD_QUAD_FORMAT
#define NTV2_IS_QUAD_QUAD_FORMAT(__f__)
Definition: ntv2enums.h:813
kRegMROutControl
@ kRegMROutControl
Definition: ntv2publicinterface.h:1054
NTV2_FORMAT_4x1920x1080psf_2398
@ NTV2_FORMAT_4x1920x1080psf_2398
Definition: ntv2enums.h:588
kRegMaskInputStatusLock
@ kRegMaskInputStatusLock
Definition: ntv2publicinterface.h:1615
CNTV2Card::GetHDMIInputVideoFormat
virtual NTV2VideoFormat GetHDMIInputVideoFormat(NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Definition: ntv2register.cpp:3520
kRegShiftQuadQuadMode2
@ kRegShiftQuadQuadMode2
Definition: ntv2publicinterface.h:2379
NTV2_STANDARD_2K
@ NTV2_STANDARD_2K
Definition: ntv2enums.h:166
gChannelToSDIInputRateMask
static const ULWord gChannelToSDIInputRateMask[]
Definition: ntv2register.cpp:152
kRegMaskRP188ModeCh2
@ kRegMaskRP188ModeCh2
Definition: ntv2publicinterface.h:1249
NTV2_FORMAT_1080p_2K_6000_A
@ NTV2_FORMAT_1080p_2K_6000_A
Definition: ntv2enums.h:620
kK2RegShiftVideoDACMode
@ kK2RegShiftVideoDACMode
Definition: ntv2publicinterface.h:2741
CNTV2Card::SetRS422Parity
virtual bool SetRS422Parity(const NTV2Channel inSerialPort, const NTV2_RS422_PARITY inParity)
Sets the parity control on the specified RS422 serial port.
Definition: ntv2register.cpp:4444
NTV2_FG_720x598
@ NTV2_FG_720x598
720x576, for PAL 625i, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:352
NTV2_FBF_10BIT_YCBCR
@ NTV2_FBF_10BIT_YCBCR
See 10-Bit YCbCr Format.
Definition: ntv2enums.h:216
gChannelToGlobalControlRegNum
static const ULWord gChannelToGlobalControlRegNum[]
Definition: ntv2register.cpp:68
kRegShiftSmpte372Enable6
@ kRegShiftSmpte372Enable6
Definition: ntv2publicinterface.h:2359
CNTV2Card::SetVideoDACMode
virtual bool SetVideoDACMode(NTV2VideoDACMode inValue)
Definition: ntv2register.cpp:3259
ntv2vpid.h
Declares the CNTV2VPID class. See SMPTE 352 standard for details.
kRegRXSDI5CRCErrorCount
@ kRegRXSDI5CRCErrorCount
Definition: ntv2publicinterface.h:757
CNTV2Card::EnableFramePulseReference
virtual bool EnableFramePulseReference(const bool inEnable)
Enables the device's frame pulse reference select.
Definition: ntv2register.cpp:1584
kRegShiftIndependentMode
@ kRegShiftIndependentMode
Definition: ntv2publicinterface.h:2361
CNTV2Card::GetSDITRSError
virtual bool GetSDITRSError(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4255
NTV2EncodeAsPSF
NTV2EncodeAsPSF
Definition: ntv2enums.h:2501
kVRegFlashStatus
@ kVRegFlashStatus
Definition: ntv2virtualregisters.h:302
kRegShiftSDIRelayControl12
@ kRegShiftSDIRelayControl12
Definition: ntv2publicinterface.h:3156
kRegRXSDIFreeRunningClockLow
@ kRegRXSDIFreeRunningClockLow
Definition: ntv2publicinterface.h:792
NTV2_FRAMESIZE_2MB
@ NTV2_FRAMESIZE_2MB
Definition: ntv2enums.h:2107
CNTV2Card::GetDualLinkInputEnable
virtual bool GetDualLinkInputEnable(bool &outIsEnabled)
Definition: ntv2register.cpp:3226
kRegRP188InOut2Bits32_63
@ kRegRP188InOut2Bits32_63
Definition: ntv2publicinterface.h:187
CNTV2Card::GetDualLinkOutputEnable
virtual bool GetDualLinkOutputEnable(bool &outIsEnabled)
Definition: ntv2register.cpp:3213
CNTV2Card::SetMixerRGBRange
virtual bool SetMixerRGBRange(const UWord inWhichMixer, const NTV2MixerRGBRange inRGBRange)
Sets the RGB range for the given mixer/keyer.
Definition: ntv2register.cpp:3118
kRegSDIInput3GStatus2
@ kRegSDIInput3GStatus2
Definition: ntv2publicinterface.h:428
kRegMaskSDIIn8LevelBtoLevelA
@ kRegMaskSDIIn8LevelBtoLevelA
Definition: ntv2publicinterface.h:2032
NTV2_IS_QUAD_FRAME_GEOMETRY
#define NTV2_IS_QUAD_FRAME_GEOMETRY(geom)
Definition: ntv2enums.h:379
NTV2_RS422_EVEN_PARITY
@ NTV2_RS422_EVEN_PARITY
Even parity.
Definition: ntv2enums.h:4144
NTV2_FORMAT_4096x2160p_3000
@ NTV2_FORMAT_4096x2160p_3000
Definition: ntv2enums.h:659
kK2RegMaskSDIOutStandard
@ kK2RegMaskSDIOutStandard
Definition: ntv2publicinterface.h:1668
DEC
#define DEC(__x__)
Definition: ntv2publicinterface.h:5765
CNTV2Card::SetSDIOutputStandard
virtual bool SetSDIOutputStandard(const UWord inOutputSpigot, const NTV2Standard inValue)
Sets the SDI output spigot's video standard.
Definition: ntv2register.cpp:3264
kK2RegMaskSDIOutDS2AudioSelect
@ kK2RegMaskSDIOutDS2AudioSelect
Definition: ntv2publicinterface.h:1688
BIT_23
#define BIT_23
Definition: ajatypes.h:597
kRegShiftAutodetect64
@ kRegShiftAutodetect64
Definition: ntv2publicinterface.h:2528
NTV2VideoLimiting
NTV2VideoLimiting
These enum values identify the available SDI video output limiting modes.
Definition: ntv2enums.h:3756
kRegSDIOut1Control
@ kRegSDIOut1Control
Definition: ntv2publicinterface.h:262
gChannelToSDIInputGeometryMask
static const ULWord gChannelToSDIInputGeometryMask[]
Definition: ntv2register.cpp:161
NTV2_FORMAT_4x1920x1080psf_2500
@ NTV2_FORMAT_4x1920x1080psf_2500
Definition: ntv2enums.h:590
NTV2SDIInStatistics
This is used by the CNTV2Card::ReadSDIStatistics function.
Definition: ntv2publicinterface.h:7953
NTV2_FRAMERATE_5994
@ NTV2_FRAMERATE_5994
Fractional rate of 60,000 frames per 1,001 seconds.
Definition: ntv2enums.h:411
kRegShiftFramePulseRefSelect
@ kRegShiftFramePulseRefSelect
Definition: ntv2publicinterface.h:2383
CNTV2Card::DisableChannels
virtual bool DisableChannels(const NTV2ChannelSet &inChannels)
Disables the given FrameStore(s).
Definition: ntv2register.cpp:2151
false
#define false
Definition: ntv2devicefeatures.h:25
kRegMaskSDI6Transmit
@ kRegMaskSDI6Transmit
Definition: ntv2publicinterface.h:2087
NTV2RegInfo
Everything needed to call CNTV2Card::ReadRegister or CNTV2Card::WriteRegister functions.
Definition: ntv2publicinterface.h:4046
kK2RegMaskSDIOutDS2Audio_Bit2
@ kK2RegMaskSDIOutDS2Audio_Bit2
Definition: ntv2publicinterface.h:1684
NTV2OutputXptIDSetConstIter
NTV2OutputXptIDSet::const_iterator NTV2OutputXptIDSetConstIter
A const iterator for iterating over an NTV2OutputXptIDSet.
Definition: ntv2signalrouter.h:19
kRegMaskIndependentMode
@ kRegMaskIndependentMode
Definition: ntv2publicinterface.h:1268
DEVICE_ID_CORVID24
@ DEVICE_ID_CORVID24
See Corvid 24.
Definition: ntv2enums.h:24
NTV2_FORMAT_4x3840x2160p_2400
@ NTV2_FORMAT_4x3840x2160p_2400
Definition: ntv2enums.h:687
CNTV2Card::Enable4KPSFOutMode
virtual bool Enable4KPSFOutMode(bool inEnable)
Sets 4K Down Convert PSF out Mode.
Definition: ntv2register.cpp:4241
UByte
uint8_t UByte
Definition: ajatypes.h:251
NTV2RegisterWrites
std::vector< NTV2RegInfo > NTV2RegisterWrites
Definition: ntv2publicinterface.h:4138
kRegRXSDI6Status
@ kRegRXSDI6Status
Definition: ntv2publicinterface.h:765
NTV2_STANDARD_525
@ NTV2_STANDARD_525
Identifies SMPTE SD 525i.
Definition: ntv2enums.h:163
gChannelToSDIInputGeometryHighShift
static const ULWord gChannelToSDIInputGeometryHighShift[]
Definition: ntv2register.cpp:167
kRegShiftHDMIInV2VideoStd
@ kRegShiftHDMIInV2VideoStd
Definition: ntv2publicinterface.h:2705
kK2RegMaskVideoDACMode
@ kK2RegMaskVideoDACMode
Definition: ntv2publicinterface.h:1656
gChannelToInputFrameRegNum
static const ULWord gChannelToInputFrameRegNum[]
Definition: ntv2register.cpp:80
CNTV2Card::SetSDIOut12GEnable
virtual bool SetSDIOut12GEnable(const NTV2Channel inChannel, const bool inEnable)
Definition: ntv2register.cpp:3974
CNTV2Card::BankSelectReadRegister
virtual bool BankSelectReadRegister(const NTV2RegInfo &inBankSelect, NTV2RegInfo &inOutRegInfo)
Reads the given set of registers from the bank specified in position 0.
Definition: ntv2register.cpp:4680
kRegRXSDI2Status
@ kRegRXSDI2Status
Definition: ntv2publicinterface.h:729
NTV2_FRAMESIZE_26MB
@ NTV2_FRAMESIZE_26MB
Definition: ntv2enums.h:2119
kK2RegMaskSDIOutDS1AudioSelect
@ kK2RegMaskSDIOutDS1AudioSelect
Definition: ntv2publicinterface.h:1687
CNTV2Card::SetMixerVancOutputFromForeground
virtual bool SetMixerVancOutputFromForeground(const UWord inWhichMixer, const bool inFromForegroundSource=(!(0)))
Sets the VANC source for the given mixer/keyer to the foreground video (or not). See the SDI Ancillar...
Definition: ntv2register.cpp:2917
kRegMaskInput1Progressive
@ kRegMaskInput1Progressive
Definition: ntv2publicinterface.h:1414
CNTV2Card::GetCRCErrorCountA
virtual ULWord GetCRCErrorCountA(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4288
CNTV2Card::Get4kSquaresEnable
virtual bool Get4kSquaresEnable(bool &outIsEnabled, const NTV2Channel inChannel)
Answers whether the FrameStore bank's current SMPTE 425 "4K squares" (i.e., "2K quadrants") mode is e...
Definition: ntv2register.cpp:1289
kRegCh6Control
@ kRegCh6Control
Definition: ntv2publicinterface.h:558
NTV2RegInfo::registerNumber
ULWord registerNumber
My register number to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4047
CNTV2Card::GetFrameBufferQuarterSizeMode
virtual bool GetFrameBufferQuarterSizeMode(NTV2Channel inChannel, NTV2QuarterSizeExpandMode &outValue)
Definition: ntv2register.cpp:1967
ntv2konaflashprogram.h
Declares the CNTV2KonaFlashProgram class.
NTV2_FORMAT_4x2048x1080p_2500
@ NTV2_FORMAT_4x2048x1080p_2500
Definition: ntv2enums.h:599
kLHIRegMaskSDIOutSMPTELevelBMode
@ kLHIRegMaskSDIOutSMPTELevelBMode
Definition: ntv2publicinterface.h:1678
NTV2_RP188::IsValid
bool IsValid(void) const
Answers true if I'm valid, or false if I'm not valid.
Definition: ntv2publicinterface.h:7040
NTV2_FORMAT_4x1920x1080p_5994
@ NTV2_FORMAT_4x1920x1080p_5994
Definition: ntv2enums.h:609
NTV2_FORMAT_720p_2398
@ NTV2_FORMAT_720p_2398
Definition: ntv2enums.h:561
NTV2_FORMAT_4x4096x2160p_5000
@ NTV2_FORMAT_4x4096x2160p_5000
Definition: ntv2enums.h:706
NTV2FrameBufferFormatToString
std::string NTV2FrameBufferFormatToString(const NTV2FrameBufferFormat inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6828
CNTV2Card::GetProgressivePicture
virtual bool GetProgressivePicture(ULWord &outValue)
Definition: ntv2register.cpp:1081
NTV2RegisterWriteMode
NTV2RegisterWriteMode
These values are used to determine when certain register writes actually take effect....
Definition: ntv2enums.h:1668
CNTV2Card::GetBaseAddress
virtual bool GetBaseAddress(NTV2Channel channel, ULWord **pBaseAddress)
Definition: ntv2register.cpp:3141
CNTV2Card::GetAnalogOutHTiming
virtual bool GetAnalogOutHTiming(ULWord &outValue)
Definition: ntv2register.cpp:3262
kRegRP188InOut4DBB
@ kRegRP188InOut4DBB
Definition: ntv2publicinterface.h:414
kRegShiftAnalogCompositeFormat625
@ kRegShiftAnalogCompositeFormat625
Definition: ntv2publicinterface.h:2671
NTV2_INPUTSOURCE_SDI8
@ NTV2_INPUTSOURCE_SDI8
Identifies the 8th SDI video input.
Definition: ntv2enums.h:1270
NTV2_FORMAT_4x3840x2160p_6000
@ NTV2_FORMAT_4x3840x2160p_6000
Definition: ntv2enums.h:693
kRegRXSDI3Status
@ kRegRXSDI3Status
Definition: ntv2publicinterface.h:738
NTV2_IS_VALID_VIDEOLIMITING
#define NTV2_IS_VALID_VIDEOLIMITING(__v__)
Definition: ntv2enums.h:3765
kRegMaskRefSource
@ kRegMaskRefSource
Definition: ntv2publicinterface.h:1239
NTV2_STANDARD_3840HFR
@ NTV2_STANDARD_3840HFR
Identifies high frame-rate UHD.
Definition: ntv2enums.h:171
NTV2_FRAMESIZE_14MB
@ NTV2_FRAMESIZE_14MB
Definition: ntv2enums.h:2114
gChannelToControlRegNum
static const ULWord gChannelToControlRegNum[]
Definition: ntv2register.cpp:74
NTV2_FRAMESIZE_8MB
@ NTV2_FRAMESIZE_8MB
Definition: ntv2enums.h:2109
CNTV2VPID::GetVideoFormat
virtual NTV2VideoFormat GetVideoFormat(void) const
Definition: ntv2vpid.cpp:674
kRegCh4Control
@ kRegCh4Control
Definition: ntv2publicinterface.h:401
CNTV2Card::GetProgramStatus
virtual bool GetProgramStatus(SSC_GET_FIRMWARE_PROGRESS_STRUCT *statusStruct)
Definition: ntv2register.cpp:2321
kRegCh8Control2MFrame
@ kRegCh8Control2MFrame
Definition: ntv2publicinterface.h:701
ULWord64
uint64_t ULWord64
Definition: ajatypes.h:259
kRegCh1OutputFrame
@ kRegCh1OutputFrame
Definition: ntv2publicinterface.h:123
CNTV2Card::GetSDIInLevelBtoLevelAConversion
virtual bool GetSDIInLevelBtoLevelAConversion(const UWord inInputSpigot, bool &outIsEnabled)
Answers with the device's current 3G level B to 3G level A conversion setting for the given SDI input...
Definition: ntv2register.cpp:4342
NTV2_INPUTSOURCE_SDI2
@ NTV2_INPUTSOURCE_SDI2
Identifies the 2nd SDI video input.
Definition: ntv2enums.h:1264
NTV2_FRAMESIZE_6MB
@ NTV2_FRAMESIZE_6MB
Definition: ntv2enums.h:2111
kRegInputStatus
@ kRegInputStatus
Definition: ntv2publicinterface.h:143
K2_MIN_V
#define K2_MIN_V
Definition: ntv2register.cpp:48
std
Definition: json.hpp:5362
gChannelToSDIIn3GModeMask
static const ULWord gChannelToSDIIn3GModeMask[]
Definition: ntv2register.cpp:132
kRegMaskSDIIn53GbpsMode
@ kRegMaskSDIIn53GbpsMode
Definition: ntv2publicinterface.h:2009
NTV2_RP188
This struct replaces the old RP188_STRUCT.
Definition: ntv2publicinterface.h:6998
CNTV2Card::SetLTCEmbeddedOutEnable
virtual bool SetLTCEmbeddedOutEnable(const bool inNewValue)
Definition: ntv2register.cpp:3748
kRegRXSDI2CRCErrorCount
@ kRegRXSDI2CRCErrorCount
Definition: ntv2publicinterface.h:730
CNTV2Card::SetMixerMode
virtual bool SetMixerMode(const UWord inWhichMixer, const NTV2MixerKeyerMode inMode)
Sets the mode for the given mixer/keyer.
Definition: ntv2register.cpp:2984
CNTV2SignalRouter::WidgetIDToType
static NTV2WidgetType WidgetIDToType(const NTV2WidgetID inWidgetID)
Definition: ntv2signalrouter.cpp:559
NTV2RegInfo::registerShift
ULWord registerShift
My register shift value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4050
NTV2_STANDARD_2Kx1080i
@ NTV2_STANDARD_2Kx1080i
Identifies SMPTE HD 2K1080psf.
Definition: ntv2enums.h:168
NTV2_FRAMERATE_UNKNOWN
@ NTV2_FRAMERATE_UNKNOWN
Represents an unknown or invalid frame rate.
Definition: ntv2enums.h:408
kRegFlatMatte4Value
@ kRegFlatMatte4Value
Definition: ntv2publicinterface.h:682
CNTV2Card::GetDisabledChannels
virtual bool GetDisabledChannels(NTV2ChannelSet &outChannels)
Answers with the set of channels that are currently disabled.
Definition: ntv2register.cpp:2214
NTV2_RS422_BAUD_RATE_38400
@ NTV2_RS422_BAUD_RATE_38400
38400 baud – this is the power-up default
Definition: ntv2enums.h:4157
kRegMaskSDIWatchdogStatus
@ kRegMaskSDIWatchdogStatus
Definition: ntv2publicinterface.h:2102
NTV2_FORMAT_1080p_5000_A
@ NTV2_FORMAT_1080p_5000_A
Definition: ntv2enums.h:563
NTV2FrameBufferQuality
NTV2FrameBufferQuality
Definition: ntv2enums.h:2486
NTV2_FORMAT_4x2048x1080p_6000
@ NTV2_FORMAT_4x2048x1080p_6000
Definition: ntv2enums.h:613
gChannelToSDIIn12GModeShift
static const ULWord gChannelToSDIIn12GModeShift[]
Definition: ntv2register.cpp:146
kRegMaskDitherOn8BitInput
@ kRegMaskDitherOn8BitInput
Definition: ntv2publicinterface.h:1316
kDeviceCanDo8KVideo
@ kDeviceCanDo8KVideo
True if device supports 8K video formats.
Definition: ntv2devicefeatures.h:120
NTV2_RS422_BAUD_RATE_INVALID
@ NTV2_RS422_BAUD_RATE_INVALID
Definition: ntv2enums.h:4160
NTV2_FORMAT_3840x2160psf_2997
@ NTV2_FORMAT_3840x2160psf_2997
Definition: ntv2enums.h:642
kRegShiftSDI8Transmit
@ kRegShiftSDI8Transmit
Definition: ntv2publicinterface.h:3149
NTV2VideoFormat
enum _NTV2VideoFormat NTV2VideoFormat
Identifies a particular video format.
kRegShiftSDIIn33GbpsMode
@ kRegShiftSDIIn33GbpsMode
Definition: ntv2publicinterface.h:3057
kRegGlobalControlCh2
@ kRegGlobalControlCh2
Definition: ntv2publicinterface.h:545
NTV2_STANDARD_8192
@ NTV2_STANDARD_8192
Identifies 8K.
Definition: ntv2enums.h:174
gMatteColorRegs
static const ULWord gMatteColorRegs[]
Definition: ntv2register.cpp:3068
CNTV2Card::SetSDIRelayManualControl
virtual bool SetSDIRelayManualControl(const NTV2RelayState inValue, const UWord inIndex0)
Sets the state of the given connector pair relays to NTV2_DEVICE_BYPASSED (or NTV2_THROUGH_DEVICE if ...
Definition: ntv2register.cpp:4149
AJA_sERROR
#define AJA_sERROR(_index_, _expr_)
Definition: debug.h:176
kRegShiftLTCInPresent
@ kRegShiftLTCInPresent
Definition: ntv2publicinterface.h:2453
NTV2_FORMAT_4096x2160p_5000
@ NTV2_FORMAT_4096x2160p_5000
Definition: ntv2enums.h:664
NTV2_FRAMESIZE_22MB
@ NTV2_FRAMESIZE_22MB
Definition: ntv2enums.h:2117
CNTV2Card::SetRS422BaudRate
virtual bool SetRS422BaudRate(const NTV2Channel inSerialPort, const NTV2_RS422_BAUD_RATE inBaudRate)
Sets the baud rate of the specified RS422 serial port.
Definition: ntv2register.cpp:4495
kRegShiftSDIIn2LevelBtoLevelA
@ kRegShiftSDIIn2LevelBtoLevelA
Definition: ntv2publicinterface.h:3049
kRegCh7InputFrame
@ kRegCh7InputFrame
Definition: ntv2publicinterface.h:565
NTV2_FORMAT_1080i_5000
@ NTV2_FORMAT_1080i_5000
Definition: ntv2enums.h:541
kRegMask2MFrameSize
@ kRegMask2MFrameSize
Definition: ntv2publicinterface.h:2125
kK2RegShiftSDIOutDS2AudioSelect
@ kK2RegShiftSDIOutDS2AudioSelect
Definition: ntv2publicinterface.h:2767
CNTV2VPID::GetProgressiveTransport
virtual bool GetProgressiveTransport(void) const
Definition: ntv2vpid.cpp:332
kRegVidProc2Control
@ kRegVidProc2Control
Definition: ntv2publicinterface.h:388
CNTV2Card::SetSDIOut3GbEnable
virtual bool SetSDIOut3GbEnable(const NTV2Channel inChannel, const bool inEnable)
Definition: ntv2register.cpp:3935
kRegMaskFrameRate
@ kRegMaskFrameRate
Definition: ntv2publicinterface.h:1235
kRegCh1ControlExtended
@ kRegCh1ControlExtended
Definition: ntv2publicinterface.h:303
CNTV2Card::SetMultiRasterBypassEnable
virtual bool SetMultiRasterBypassEnable(const bool inEnable)
Definition: ntv2register.cpp:4753
CNTV2SignalRouter::GetWidgetInputs
static bool GetWidgetInputs(const NTV2WidgetID inWidgetID, NTV2InputXptIDSet &outInputs)
Returns the input crosspoints known to be "owned" by the given widget.
Definition: ntv2signalrouter.cpp:444
NTV2_FORMAT_4x1920x1080p_5000
@ NTV2_FORMAT_4x1920x1080p_5000
Definition: ntv2enums.h:608
NTV2PossibleConnections
std::multimap< NTV2InputXptID, NTV2OutputXptID > NTV2PossibleConnections
A map of zero or more one-to-many possible NTV2InputXptID to NTV2OutputXptID connections.
Definition: ntv2signalrouter.h:41
NTV2_DEVICE_BYPASSED
@ NTV2_DEVICE_BYPASSED
Input & output directly connected.
Definition: ntv2enums.h:3916
AJA_FALL_THRU
#define AJA_FALL_THRU
Definition: ajatypes.h:220
kRegMaskFrameOrientation
@ kRegMaskFrameOrientation
Definition: ntv2publicinterface.h:1311
kRegCh7Control2MFrame
@ kRegCh7Control2MFrame
Definition: ntv2publicinterface.h:700
NTV2_STANDARD_720
@ NTV2_STANDARD_720
Identifies SMPTE HD 720p.
Definition: ntv2enums.h:162
kRegCh6PCIAccessFrame
@ kRegCh6PCIAccessFrame
Definition: ntv2publicinterface.h:561
NTV2_RS422_NO_PARITY
@ NTV2_RS422_NO_PARITY
No parity.
Definition: ntv2enums.h:4142
NTV2_FORMAT_4x1920x1080p_2398
@ NTV2_FORMAT_4x1920x1080p_2398
Definition: ntv2enums.h:591
NTV2_FG_2048x1112
@ NTV2_FG_2048x1112
2048x1080, for 2Kx1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:358
kRegMaskSDIIn73GbpsMode
@ kRegMaskSDIIn73GbpsMode
Definition: ntv2publicinterface.h:2023
CNTV2Card::AbortMailBoxLock
virtual bool AbortMailBoxLock(void)
Definition: ntv2register.cpp:4552
kRegShiftQuality
@ kRegShiftQuality
Definition: ntv2publicinterface.h:2408
CNTV2Card::ReadVirtualData
virtual bool ReadVirtualData(const ULWord inTag, void *outVirtualData, const ULWord inVirtualDataSize)
Reads the block of virtual data for a specific tag.
Definition: ntv2register.cpp:4700
CNTV2Card::SetSDIOutputDS2AudioSystem
virtual bool SetSDIOutputDS2AudioSystem(const NTV2Channel inSDIOutputConnector, const NTV2AudioSystem inAudioSystem)
Sets the Audio System that will supply audio for the given SDI output's audio embedder for Data Strea...
Definition: ntv2register.cpp:4067
NTV2FrameGeometry
NTV2FrameGeometry
Identifies a particular video frame geometry.
Definition: ntv2enums.h:342
CNTV2Card::IsChannelEnabled
virtual bool IsChannelEnabled(const NTV2Channel inChannel, bool &outEnabled)
Answers whether or not the given FrameStore is enabled.
Definition: ntv2register.cpp:2186
kRegShiftVidProcSyncFail
@ kRegShiftVidProcSyncFail
Definition: ntv2publicinterface.h:2443
kDeviceCanDo425Mux
@ kDeviceCanDo425Mux
True if the device supports SMPTE 425 mux control.
Definition: ntv2devicefeatures.h:43
kProgramStateFinished
@ kProgramStateFinished
Definition: ntv2publicinterface.h:5042
NTV2_FORMAT_1080p_6000_B
@ NTV2_FORMAT_1080p_6000_B
Definition: ntv2enums.h:560
CNTV2Card::WriteAnalogLTCOutput
virtual bool WriteAnalogLTCOutput(const UWord inLTCOutput, const RP188_STRUCT &inRP188Data)
Writes the given timecode to the specified analog LTC output register.
Definition: ntv2register.cpp:3805
CNTV2DriverInterface::GetFrameBufferSize
virtual ULWord GetFrameBufferSize(void) const
Definition: ntv2driverinterface.h:379
kRegMaskRP188ModeCh3
@ kRegMaskRP188ModeCh3
Definition: ntv2publicinterface.h:1276
NTV2EveryFrameTaskMode
NTV2EveryFrameTaskMode
Describes the task mode state. See also: Sharing AJA Devices With Other Applications.
Definition: ntv2publicinterface.h:4462
GetQuadSizedVideoFormat
NTV2VideoFormat GetQuadSizedVideoFormat(const NTV2VideoFormat inVideoFormat, const bool isSquareDivision=true)
Definition: ntv2utils.cpp:2033
kRegCh8PCIAccessFrame
@ kRegCh8PCIAccessFrame
Definition: ntv2publicinterface.h:571
NTV2_FORMAT_4096x2160p_2997
@ NTV2_FORMAT_4096x2160p_2997
Definition: ntv2enums.h:658
kRegMaskSDI1Transmit
@ kRegMaskSDI1Transmit
Definition: ntv2publicinterface.h:2090
CNTV2Card::GetMixerRGBRange
virtual bool GetMixerRGBRange(const UWord inWhichMixer, NTV2MixerRGBRange &outRGBRange)
Answers with the given mixer/keyer's current RGB Range.
Definition: ntv2register.cpp:3125
true
#define true
Definition: ntv2devicefeatures.h:26
kFS1RefShiftLTCOnRefInSelect
@ kFS1RefShiftLTCOnRefInSelect
Definition: ntv2publicinterface.h:2633
kRegMaskSDI2Transmit
@ kRegMaskSDI2Transmit
Definition: ntv2publicinterface.h:2091
gChannelToSDIIn3GModeShift
static const ULWord gChannelToSDIIn3GModeShift[]
Definition: ntv2register.cpp:135
kRegMaskPCRReferenceEnable
@ kRegMaskPCRReferenceEnable
Definition: ntv2publicinterface.h:1254
CNTV2Card::SetInputVideoSelect
virtual bool SetInputVideoSelect(NTV2InputVideoSelect inInputSelect)
Definition: ntv2register.cpp:3416
CVIDFAIL
#define CVIDFAIL(__x__)
Definition: ntv2register.cpp:26
kK2RegMaskFrameSize
@ kK2RegMaskFrameSize
Definition: ntv2publicinterface.h:1319
NTV2SetRegisters
This is used by the CNTV2Card::WriteRegisters function.
Definition: ntv2publicinterface.h:7799
kRegShiftSDIIn4LevelBtoLevelA
@ kRegShiftSDIIn4LevelBtoLevelA
Definition: ntv2publicinterface.h:3066
NTV2_IS_QUAD_FRAME_FORMAT
#define NTV2_IS_QUAD_FRAME_FORMAT(__f__)
Definition: ntv2enums.h:806
kRegCh1Control
@ kRegCh1Control
Definition: ntv2publicinterface.h:121
kRegMRQ2Control
@ kRegMRQ2Control
Definition: ntv2publicinterface.h:1051
CNTV2Card::IsMultiRasterWidgetChannel
virtual bool IsMultiRasterWidgetChannel(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4777
NTV2_FORMAT_1080p_5994_A
@ NTV2_FORMAT_1080p_5994_A
Definition: ntv2enums.h:564
NTV2_FG_2048x1114
@ NTV2_FG_2048x1114
2048x1080, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:350
NTV2VideoLimitingToString
std::string NTV2VideoLimitingToString(const NTV2VideoLimiting inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6437
CNTV2Card::SetDefaultVideoOutMode
virtual bool SetDefaultVideoOutMode(ULWord mode)
Definition: ntv2register.cpp:190
CNTV2Card::GetMixerFGMatteEnabled
virtual bool GetMixerFGMatteEnabled(const UWord inWhichMixer, bool &outIsEnabled)
Answers if the given mixer/keyer's foreground matte is enabled or not.
Definition: ntv2register.cpp:3038
NTV2SetRegisters::mOutNumFailures
ULWord mOutNumFailures
The number of registers unsuccessfully written.
Definition: ntv2publicinterface.h:7803
NTV2_IS_VALID_NTV2FrameRate
#define NTV2_IS_VALID_NTV2FrameRate(__r__)
Definition: ntv2enums.h:438
CNTV2Card::GetEveryFrameServices
virtual bool GetEveryFrameServices(NTV2EveryFrameTaskMode &outMode)
Retrieves the device's current "retail service" task mode.
Definition: ntv2register.cpp:184
kRegShiftSDIIn43GbpsMode
@ kRegShiftSDIIn43GbpsMode
Definition: ntv2publicinterface.h:3064
CNTV2Card::IsBufferSizeSetBySW
virtual bool IsBufferSizeSetBySW(void)
Definition: ntv2register.cpp:1696
Get4xSizedStandard
NTV2Standard Get4xSizedStandard(const NTV2Standard inGeometry, const bool bIs4k=false)
Definition: ntv2utils.cpp:2261
CNTV2Card::GetPCIDeviceID
virtual bool GetPCIDeviceID(ULWord &outPCIDeviceID)
Answers with my PCI device ID.
Definition: ntv2register.cpp:2467
gChlToRP188Bits031RegNum
static const ULWord gChlToRP188Bits031RegNum[]
Definition: ntv2register.cpp:117
NTV2_FORMAT_4x2048x1080p_5994
@ NTV2_FORMAT_4x2048x1080p_5994
Definition: ntv2enums.h:612
kRegMixer2Coefficient
@ kRegMixer2Coefficient
Definition: ntv2publicinterface.h:389
CNTV2Card::GetFrameRate
virtual bool GetFrameRate(NTV2FrameRate &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the AJA device's currently configured frame rate via its "value" parameter.
Definition: ntv2register.cpp:1022
CNTV2Card::SetInputFrame
virtual bool SetInputFrame(const NTV2Channel inChannel, const ULWord inValue)
Sets the input frame index number for the given FrameStore. This identifies which frame in device SDR...
Definition: ntv2register.cpp:2273
NTV2WidgetType_SDIIn3G
@ NTV2WidgetType_SDIIn3G
Definition: ntv2enums.h:3035
NTV2_FBQualityInvalid
@ NTV2_FBQualityInvalid
Definition: ntv2enums.h:2495
kRegCh7OutputFrame
@ kRegCh7OutputFrame
Definition: ntv2publicinterface.h:564
kRegLPPTPSFPStatus
@ kRegLPPTPSFPStatus
Definition: ntv2publicinterface.h:1118
NTV2RegInfo::registerMask
ULWord registerMask
My register mask value to use in a ReadRegister or WriteRegister call.
Definition: ntv2publicinterface.h:4049
kRegCh2ControlExtended
@ kRegCh2ControlExtended
Definition: ntv2publicinterface.h:304
CNTV2Card::SetEnableVANCData
virtual bool SetEnableVANCData(const bool inVANCenabled, const bool inTallerVANC, const NTV2Standard inStandard, const NTV2FrameGeometry inGeometry, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:2784
kRegMaskForce64
@ kRegMaskForce64
Definition: ntv2publicinterface.h:1435
kRegCh4OutputFrame
@ kRegCh4OutputFrame
Definition: ntv2publicinterface.h:402
CNTV2VPID::SetVPID
virtual CNTV2VPID & SetVPID(const ULWord inData)
Definition: ntv2vpid.h:71
kRegShiftSDIWatchdogEnable12
@ kRegShiftSDIWatchdogEnable12
Definition: ntv2publicinterface.h:3158
CNTV2Card::GetAllWidgetOutputs
virtual bool GetAllWidgetOutputs(NTV2OutputXptIDSet &outOutputs)
Returns all my widget output crosspoints.
Definition: ntv2register.cpp:1848
NTV2_FG_4x1920x1080
@ NTV2_FG_4x1920x1080
3840x2160, for UHD, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:361
NTV2VANCDataShiftMode
NTV2VANCDataShiftMode
Definition: ntv2enums.h:3791
CNTV2Card::IsRP188BypassEnabled
virtual bool IsRP188BypassEnabled(const NTV2Channel inSDIOutput, bool &outIsBypassEnabled)
Answers if the SDI output's RP-188 bypass mode is enabled or not.
Definition: ntv2register.cpp:2613
CNTV2Card::DisableRP188Bypass
virtual bool DisableRP188Bypass(const NTV2Channel inSDIOutput)
Configures the SDI output's embedder to embed SMPTE 12M timecode specified in calls to CNTV2Card::Set...
Definition: ntv2register.cpp:2626
NTV2HDRLuminance
enum NTV2VPIDLuminance NTV2HDRLuminance
NTV2_FORMAT_4x3840x2160p_3000
@ NTV2_FORMAT_4x3840x2160p_3000
Definition: ntv2enums.h:690
kRegShift425FB56
@ kRegShift425FB56
Definition: ntv2publicinterface.h:2367
kK2RegShiftSDIOutDS1AudioSelect
@ kK2RegShiftSDIOutDS1AudioSelect
Definition: ntv2publicinterface.h:2766
NTV2VirtualData
This is used to perform virtual data reads or writes.
Definition: ntv2publicinterface.h:7912
kRegShiftSmpte372Enable4
@ kRegShiftSmpte372Enable4
Definition: ntv2publicinterface.h:2358
NTV2SDIInputStatus::mCRCTallyA
UWord mCRCTallyA
The number of lines having a CRC error was detected in the "B" stream of the SDI link since this tall...
Definition: ntv2publicinterface.h:7105
CNTV2Card::SetQuadQuadFrameEnable
virtual bool SetQuadQuadFrameEnable(const bool inValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Enables or disables "quad-quad" 8K frame mode on the device.
Definition: ntv2register.cpp:1125
kRegMaskAnalogCompositeLocked
@ kRegMaskAnalogCompositeLocked
Definition: ntv2publicinterface.h:1582
kRegMaskSDIIn26GbpsMode
@ kRegMaskSDIIn26GbpsMode
Definition: ntv2publicinterface.h:1987
kRegMaskSmpte372Enable8
@ kRegMaskSmpte372Enable8
Definition: ntv2publicinterface.h:1267
kRegMaskInput1GeometryHigh
@ kRegMaskInput1GeometryHigh
Definition: ntv2publicinterface.h:1427
NTV2_IS_VANCMODE_TALL
#define NTV2_IS_VANCMODE_TALL(__v__)
Definition: ntv2enums.h:3784
kDeviceGetTotalNumAudioSystems
@ kDeviceGetTotalNumAudioSystems
The total number of audio systems on the device, including host audio and mixer audio systems,...
Definition: ntv2devicefeatures.h:220
kRegRP188InOut5Bits0_31
@ kRegRP188InOut5Bits0_31
Definition: ntv2publicinterface.h:495
CVIDWARN
#define CVIDWARN(__x__)
Definition: ntv2register.cpp:27
kRegShiftRP188ModeCh8
@ kRegShiftRP188ModeCh8
Definition: ntv2publicinterface.h:2374
kRegMaskInput2Progressive
@ kRegMaskInput2Progressive
Definition: ntv2publicinterface.h:1417
kRegShiftSDIInTsiMuxSyncFail
@ kRegShiftSDIInTsiMuxSyncFail
Definition: ntv2publicinterface.h:3054
GetNTV2StandardFromVideoFormat
NTV2Standard GetNTV2StandardFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:2279
CNTV2Card::SetQuadQuadSquaresEnable
virtual bool SetQuadQuadSquaresEnable(const bool inValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Enables or disables quad-quad-frame (8K) squares mode on the device.
Definition: ntv2register.cpp:1180
kRegMaskSDI8Transmit
@ kRegMaskSDI8Transmit
Definition: ntv2publicinterface.h:2089
kRegMaskVidProcSyncFail
@ kRegMaskVidProcSyncFail
Definition: ntv2publicinterface.h:1351
CNTV2Card::ProgramMainFlash
virtual bool ProgramMainFlash(const std::string &inFileName, const bool bInForceUpdate=(0), const bool bInQuiet=(0))
Definition: ntv2register.cpp:2335
kRegShift2MFrameSize
@ kRegShift2MFrameSize
Definition: ntv2publicinterface.h:3187
NTV2SDIInputStatus::mLocked
bool mLocked
If true, a valid SDI transport was detected in the received data stream. If false,...
Definition: ntv2publicinterface.h:7115
NTV2RegReads
NTV2RegWrites NTV2RegReads
An ordered sequence of zero or more NTV2RegInfo structs intended for ReadRegister.
Definition: ntv2publicinterface.h:4141
kRegFirmwareUserID
@ kRegFirmwareUserID
Definition: ntv2publicinterface.h:336
NTV2DieTempScale
NTV2DieTempScale
Definition: ntv2enums.h:4188
kRegShift2MFrameSupport
@ kRegShift2MFrameSupport
Definition: ntv2publicinterface.h:2362
NTV2_FORMAT_3840x2160p_5000
@ NTV2_FORMAT_3840x2160p_5000
Definition: ntv2enums.h:644
kRegSDITransmitControl
@ kRegSDITransmitControl
Definition: ntv2publicinterface.h:397
CNTV2Card::SetAnalogOutHTiming
virtual bool SetAnalogOutHTiming(ULWord inValue)
Definition: ntv2register.cpp:3261
NTV2_FORMAT_720p_5994
@ NTV2_FORMAT_720p_5994
Definition: ntv2enums.h:544
NTV2_FORMAT_4096x2160psf_3000
@ NTV2_FORMAT_4096x2160psf_3000
Definition: ntv2enums.h:661
CNTV2Card::SetReference
virtual bool SetReference(const NTV2ReferenceSource inRefSource, const bool inKeepFramePulseSelect=(0))
Sets the device's clock reference source. See Video Output Clocking & Synchronization for more inform...
Definition: ntv2register.cpp:1484
kRegCh1InputFrame
@ kRegCh1InputFrame
Definition: ntv2publicinterface.h:124
kRegMaskSDIIn712GbpsMode
@ kRegMaskSDIIn712GbpsMode
Definition: ntv2publicinterface.h:2029
kRegMaskSDIIn7LevelBtoLevelA
@ kRegMaskSDIIn7LevelBtoLevelA
Definition: ntv2publicinterface.h:2025
kRegSarekPackageVersion
#define kRegSarekPackageVersion
Definition: ntv2registersmb.h:84
CNTV2Card::IsSDStandard
virtual bool IsSDStandard(bool &outIsStandardDef, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:876
NTV2_FG_1280x740
@ NTV2_FG_1280x740
1280x720, for 720p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:354
CNTV2Card::GetDitherFor8BitInputs
virtual bool GetDitherFor8BitInputs(const NTV2Channel inChannel, ULWord &outDither)
Definition: ntv2register.cpp:3242
CNTV2SignalRouter::MakeRouteROMRegisters
static bool MakeRouteROMRegisters(NTV2RegReads &outROMRegisters)
Prepares an initialized, zeroed NTV2RegReads that's prepared to read all ROM registers from a device.
Definition: ntv2signalrouter.cpp:1111
NTV2_FORMAT_1080p_2K_5000_A
@ NTV2_FORMAT_1080p_2K_5000_A
Definition: ntv2enums.h:624
NTV2_FRAMERATE_5000
@ NTV2_FRAMERATE_5000
50 frames per second
Definition: ntv2enums.h:417
CNTV2Card::GetNumberActiveLines
virtual bool GetNumberActiveLines(ULWord &outNumActiveLines)
Definition: ntv2register.cpp:772
CNTV2Card::GetSDIInputIsProgressive
virtual bool GetSDIInputIsProgressive(const NTV2Channel channel)
Definition: ntv2register.cpp:3656
kRegShiftMode
@ kRegShiftMode
Definition: ntv2publicinterface.h:2396
NTV2MixerRGBRange
NTV2MixerRGBRange
Definition: ntv2enums.h:2263
kRegShiftSDIWatchdogEnable34
@ kRegShiftSDIWatchdogEnable34
Definition: ntv2publicinterface.h:3159
kRegMaskSDIIn212GbpsMode
@ kRegMaskSDIIn212GbpsMode
Definition: ntv2publicinterface.h:1988
kRegMaskRS422BaudRate
@ kRegMaskRS422BaudRate
Definition: ntv2publicinterface.h:1499
kRegRP188InOut7DBB
@ kRegRP188InOut7DBB
Definition: ntv2publicinterface.h:603
kRegMaskSDIIn4LevelBtoLevelA
@ kRegMaskSDIIn4LevelBtoLevelA
Definition: ntv2publicinterface.h:2002
CNTV2Card::GetLTCInputEnable
virtual bool GetLTCInputEnable(bool &outIsEnabled)
Answers true if the device is currently configured to read analog LTC from the reference input connec...
Definition: ntv2register.cpp:3723
kRegMask4KDCRGBMode
@ kRegMask4KDCRGBMode
Definition: ntv2publicinterface.h:2105
kRegCh5Control
@ kRegCh5Control
Definition: ntv2publicinterface.h:553
NTV2_FORMAT_4x2048x1080psf_2500
@ NTV2_FORMAT_4x2048x1080psf_2500
Definition: ntv2enums.h:596
YCbCr10BitPixel::y
UWord y
Definition: ntv2videodefines.h:203
NTV2_INPUTSOURCE_SDI3
@ NTV2_INPUTSOURCE_SDI3
Identifies the 3rd SDI video input.
Definition: ntv2enums.h:1265
CNTV2Card::GetRS422BaudRate
virtual bool GetRS422BaudRate(const NTV2Channel inSerialPort, NTV2_RS422_BAUD_RATE &outBaudRate)
Answers with the current baud rate of the specified RS422 serial port.
Definition: ntv2register.cpp:4517
kRegShiftQuadMode2
@ kRegShiftQuadMode2
Definition: ntv2publicinterface.h:2357
NTV2OutputCrosspointIDToString
std::string NTV2OutputCrosspointIDToString(const NTV2OutputCrosspointID inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5857
kRegShiftRefSource2
@ kRegShiftRefSource2
Definition: ntv2publicinterface.h:2346
CNTV2KonaFlashProgram
Definition: ntv2konaflashprogram.h:47
NTV2_FG_2048x1556
@ NTV2_FG_2048x1556
2048x1556, for 2Kx1556psf film format, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:356
kRegMaskQuadTsiEnable
@ kRegMaskQuadTsiEnable
Definition: ntv2publicinterface.h:1245
K2_MAX_H
#define K2_MAX_H
Definition: ntv2register.cpp:46
kRegRP188InOut3Bits32_63
@ kRegRP188InOut3Bits32_63
Definition: ntv2publicinterface.h:411
CNTV2Card::GetRP188Mode
virtual bool GetRP188Mode(const NTV2Channel inChannel, NTV2_RP188Mode &outMode)
Returns the current RP188 mode – NTV2_RP188_INPUT or NTV2_RP188_OUTPUT – for the given channel.
Definition: ntv2register.cpp:2563
kRegCh6InputFrame
@ kRegCh6InputFrame
Definition: ntv2publicinterface.h:560
NTV2_REFERENCE_EXTERNAL
@ NTV2_REFERENCE_EXTERNAL
Specifies the External Reference connector.
Definition: ntv2enums.h:1445
kRegCh1PCIAccessFrame
@ kRegCh1PCIAccessFrame
Definition: ntv2publicinterface.h:122
NTV2_FRAMERATE_4795
@ NTV2_FRAMERATE_4795
Fractional rate of 48,000 frames per 1,001 seconds.
Definition: ntv2enums.h:419
NTV2_FORMAT_2K_1500
@ NTV2_FORMAT_2K_1500
Definition: ntv2enums.h:582
NTV2_IS_TSI_FORMAT
#define NTV2_IS_TSI_FORMAT(__f__)
Definition: ntv2enums.h:1186
kRegShiftRP188ModeCh5
@ kRegShiftRP188ModeCh5
Definition: ntv2publicinterface.h:2371
CNTV2Card::SetPulldownMode
virtual bool SetPulldownMode(NTV2Channel inChannel, bool inValue)
Definition: ntv2register.cpp:2895
kRegMaskRP188ModeCh8
@ kRegMaskRP188ModeCh8
Definition: ntv2publicinterface.h:1281
kRegMaskMRFrameLocation
@ kRegMaskMRFrameLocation
Definition: ntv2publicinterface.h:2281
NTV2_FRAMERATE_3000
@ NTV2_FRAMERATE_3000
30 frames per second
Definition: ntv2enums.h:412
CNTV2Card::GetSDIWatchdogStatus
virtual bool GetSDIWatchdogStatus(NTV2RelayState &outValue)
Answers if the watchdog timer would put the SDI relays into NTV2_DEVICE_BYPASSED or NTV2_THROUGH_DEVI...
Definition: ntv2register.cpp:4105
kLHIRegShiftSDIOut3GbpsMode
@ kLHIRegShiftSDIOut3GbpsMode
Definition: ntv2publicinterface.h:2762
kRegFlatMatte2Value
@ kRegFlatMatte2Value
Definition: ntv2publicinterface.h:390
kRegMaskSDIRelayPosition12
@ kRegMaskSDIRelayPosition12
Definition: ntv2publicinterface.h:2100
kRegShiftSDIIn43GbpsSMPTELevelBMode
@ kRegShiftSDIIn43GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3065
CNTV2Card::GetSDIInputVideoFormat
virtual NTV2VideoFormat GetSDIInputVideoFormat(NTV2Channel inChannel, bool inIsProgressive=(0))
Returns the video format of the signal that is present on the given SDI input source.
Definition: ntv2register.cpp:3450
kRegLTC2AnalogBits0_31
@ kRegLTC2AnalogBits0_31
Definition: ntv2publicinterface.h:395
NTV2_FRAMESIZE_16MB
@ NTV2_FRAMESIZE_16MB
Definition: ntv2enums.h:2110
BIT
#define BIT(_x_)
Definition: ajatypes.h:565
sSDIXmitEnableMasks
static const ULWord sSDIXmitEnableMasks[]
Definition: ntv2register.cpp:3855
xHEX0N
#define xHEX0N(__x__, __n__)
Definition: ntv2publicinterface.h:5764
CNTV2Card::GetSDIOutRGBLevelAConversion
virtual bool GetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, bool &outIsEnabled)
Answers with the device's current RGB-over-3G-level-A conversion at the given SDI output spigot (assu...
Definition: ntv2register.cpp:4416
kRegOutputTimingControl
@ kRegOutputTimingControl
Definition: ntv2publicinterface.h:134
NTV2AudioSystem
NTV2AudioSystem
Used to identify an Audio System on an NTV2 device. See Audio System Operation for more information.
Definition: ntv2enums.h:3873
kRegShiftDitherOn8BitInput
@ kRegShiftDitherOn8BitInput
Definition: ntv2publicinterface.h:2407
kRegShiftSDIIn83GbpsSMPTELevelBMode
@ kRegShiftSDIIn83GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3095
CNTV2Card::GetNominalMinMaxHV
virtual bool GetNominalMinMaxHV(int &outNominalH, int &outMinH, int &outMaxH, int &outNominalV, int &outMinV, int &outMaxV)
Definition: ntv2register.cpp:597
NTV2_FORMAT_525_2400
@ NTV2_FORMAT_525_2400
Definition: ntv2enums.h:576
CNTV2Card::SetDualLinkOutputEnable
virtual bool SetDualLinkOutputEnable(const bool inIsEnabled)
Definition: ntv2register.cpp:3208
kRegLineCount
@ kRegLineCount
Definition: ntv2publicinterface.h:138
CNTV2Card::GetRunningFirmwareRevision
virtual bool GetRunningFirmwareRevision(UWord &outRevision)
Reports the revision number of the currently-running firmware.
Definition: ntv2register.cpp:2364
NTV2_FG_4x3840x2160
@ NTV2_FG_4x3840x2160
7680x4320, for UHD2, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:365
CNTV2Card::SetAlphaFromInput2Bit
virtual bool SetAlphaFromInput2Bit(ULWord inValue)
Definition: ntv2register.cpp:2291
kRegShiftSDIIn63GbpsMode
@ kRegShiftSDIIn63GbpsMode
Definition: ntv2publicinterface.h:3080
NTV2_FORMAT_1080psf_2997_2
@ NTV2_FORMAT_1080psf_2997_2
Definition: ntv2enums.h:569
NTV2_RS422_PARITY_INVALID
@ NTV2_RS422_PARITY_INVALID
Definition: ntv2enums.h:4145
CNTV2KonaFlashProgram::SetBitFile
bool SetBitFile(const std::string &inBitfileName, std::ostream &outMsgs, const FlashBlockID blockNumber=AUTO_FLASHBLOCK)
Definition: ntv2konaflashprogram.cpp:428
NTV2_REFERENCE_INPUT8
@ NTV2_REFERENCE_INPUT8
Specifies the SDI In 8 connector.
Definition: ntv2enums.h:1456
kRegMaskSDIIn83GbpsMode
@ kRegMaskSDIIn83GbpsMode
Definition: ntv2publicinterface.h:2030
kRegAnalogInputStatus
@ kRegAnalogInputStatus
Definition: ntv2publicinterface.h:203
CNTV2Card::GetEnabledChannels
virtual bool GetEnabledChannels(NTV2ChannelSet &outChannels)
Answers with the set of channels that are currently enabled.
Definition: ntv2register.cpp:2200
NTV2_IS_VALID_VANCMODE
#define NTV2_IS_VALID_VANCMODE(__v__)
Definition: ntv2enums.h:3783
NTV2_FORMAT_4x4096x2160p_5994
@ NTV2_FORMAT_4x4096x2160p_5994
Definition: ntv2enums.h:707
NTV2_FORMAT_4x2048x1080p_2400
@ NTV2_FORMAT_4x2048x1080p_2400
Definition: ntv2enums.h:598
kRegMaskVidProcRGBModeSupported
@ kRegMaskVidProcRGBModeSupported
Definition: ntv2publicinterface.h:1350
kRegMaskRegClocking
@ kRegMaskRegClocking
Definition: ntv2publicinterface.h:1243
CNTV2Card::SetRegisterWriteMode
virtual bool SetRegisterWriteMode(const NTV2RegisterWriteMode inValue, const NTV2Channel inFrameStore=NTV2_CHANNEL1)
Sets the FrameStore's NTV2RegisterWriteMode, which determines when CNTV2Card::SetInputFrame or CNTV2C...
Definition: ntv2register.cpp:2512
kRegLTCStatusControl
@ kRegLTCStatusControl
Definition: ntv2publicinterface.h:374
kRegCh8InputFrame
@ kRegCh8InputFrame
Definition: ntv2publicinterface.h:570
NTV2MixerKeyerMode
NTV2MixerKeyerMode
These enum values identify the mixer mode.
Definition: ntv2enums.h:1780
CNTV2Card::EnableChannel
virtual bool EnableChannel(const NTV2Channel inChannel)
Enables the given FrameStore.
Definition: ntv2register.cpp:2161
NTV2_FRAMESIZE_INVALID
@ NTV2_FRAMESIZE_INVALID
Definition: ntv2enums.h:2124
CNTV2Card::GetSDIInputGeometry
virtual NTV2FrameGeometry GetSDIInputGeometry(const NTV2Channel channel)
Definition: ntv2register.cpp:3639
NTV2_FORMAT_1080p_2K_4800_B
@ NTV2_FORMAT_1080p_2K_4800_B
Definition: ntv2enums.h:628
kRegShiftSDIIn112GbpsMode
@ kRegShiftSDIIn112GbpsMode
Definition: ntv2publicinterface.h:3046
gChlToRP188Bits3263RegNum
static const ULWord gChlToRP188Bits3263RegNum[]
Definition: ntv2register.cpp:119
NTV2_REFERENCE_HDMI_INPUT3
@ NTV2_REFERENCE_HDMI_INPUT3
Specifies the HDMI In 3 connector.
Definition: ntv2enums.h:1462
CNTV2VPID::IsStandardMultiLink4320
virtual bool IsStandardMultiLink4320(void) const
Definition: ntv2vpid.cpp:266
NTV2_STANDARD_7680
@ NTV2_STANDARD_7680
Identifies UHD2.
Definition: ntv2enums.h:173
kRegMaskQuadMode2
@ kRegMaskQuadMode2
Definition: ntv2publicinterface.h:1264
CNTV2Card::GetSmpte372
virtual bool GetSmpte372(ULWord &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device's current SMPTE-372 (dual-link) mode, whether it's enabled or not.
Definition: ntv2register.cpp:1056
NTV2_FORMAT_4x1920x1080p_2400
@ NTV2_FORMAT_4x1920x1080p_2400
Definition: ntv2enums.h:592
ntv2registerexpert.h
Declares the CNTV2RegisterExpert class.
kRegMaskSDIIn3GbpsMode
@ kRegMaskSDIIn3GbpsMode
Definition: ntv2publicinterface.h:1975
kRegMaskSDIInUnlockCount
@ kRegMaskSDIInUnlockCount
Definition: ntv2publicinterface.h:2117
NTV2_FORMAT_4x1920x1080psf_2400
@ NTV2_FORMAT_4x1920x1080psf_2400
Definition: ntv2enums.h:589
CNTV2Card::GetTsiFrameEnable
virtual bool GetTsiFrameEnable(bool &outIsEnabled, const NTV2Channel inChannel)
Returns the current SMPTE 425 two-sample-interleave frame mode on the device, whether it's enabled or...
Definition: ntv2register.cpp:1404
kRegMaskSDIIn3GbpsSMPTELevelBMode
@ kRegMaskSDIIn3GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:1976
NTV2_FG_1920x1080
@ NTV2_FG_1920x1080
1920x1080, for 1080i and 1080p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:344
AJAFUNC
#define AJAFUNC
Definition: ajatypes.h:326
CNTV2MacDriverInterface::WriteRegister
virtual bool WriteRegister(const ULWord inRegNum, const ULWord inValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Updates or replaces all or part of the 32-bit contents of a specific register (real or virtual) on th...
Definition: ntv2macdriverinterface.cpp:438
gChannelToRS422ControlRegNum
static const ULWord gChannelToRS422ControlRegNum[]
Definition: ntv2register.cpp:86
NTV2_FRAMESIZE_24MB
@ NTV2_FRAMESIZE_24MB
Definition: ntv2enums.h:2118
NTV2_RS422_BAUD_RATE
NTV2_RS422_BAUD_RATE
These enum values identify RS-422 serial port baud rate configuration.
Definition: ntv2enums.h:4155
kRegShiftSmpte372Enable8
@ kRegShiftSmpte372Enable8
Definition: ntv2publicinterface.h:2360
CNTV2KonaFlashProgram::SetQuietMode
void SetQuietMode()
Definition: ntv2konaflashprogram.cpp:124
NTV2_FORMAT_1080psf_2500_2
@ NTV2_FORMAT_1080psf_2500_2
Definition: ntv2enums.h:568
kDeviceGetNumSerialPorts
@ kDeviceGetNumSerialPorts
The number of RS-422 serial ports on the device.
Definition: ntv2devicefeatures.h:210
gChannelToSDIInputStatusRegNum
static const ULWord gChannelToSDIInputStatusRegNum[]
Definition: ntv2register.cpp:149
kRegShiftQuarterSizeMode
@ kRegShiftQuarterSizeMode
Definition: ntv2publicinterface.h:2403
CNTV2SignalRouter::GetPossibleConnections
static bool GetPossibleConnections(const NTV2RegReads &inROMRegisters, NTV2PossibleConnections &outConnections)
Answers with the implemented crosspoint connections as obtained from the given ROM registers.
Definition: ntv2signalrouter.cpp:1094
kRegMaskRP188ModeCh1
@ kRegMaskRP188ModeCh1
Definition: ntv2publicinterface.h:1248
CNTV2Card::SetEncodeAsPSF
virtual bool SetEncodeAsPSF(NTV2Channel inChannel, NTV2EncodeAsPSF inValue)
Definition: ntv2register.cpp:2011
kRegMaskSDI5Transmit
@ kRegMaskSDI5Transmit
Definition: ntv2publicinterface.h:2086
kRegMaskInputStatusFPS
@ kRegMaskInputStatusFPS
Definition: ntv2publicinterface.h:1630
kRegMaskRP188ModeCh4
@ kRegMaskRP188ModeCh4
Definition: ntv2publicinterface.h:1277
kRegMaskInputStatusStd
@ kRegMaskInputStatusStd
Definition: ntv2publicinterface.h:1628
DEVICE_ID_KONALHI
@ DEVICE_ID_KONALHI
See KONA LHi.
Definition: ntv2enums.h:76
kRegShiftLTC2InPresent
@ kRegShiftLTC2InPresent
Definition: ntv2publicinterface.h:3032
CNTV2Card::ReadSDIStatistics
virtual bool ReadSDIStatistics(NTV2SDIInStatistics &outStats)
For devices that support it (see the NTV2DeviceCanDoSDIErrorChecks function in "ntv2devicefeatures....
Definition: ntv2register.cpp:4707
kVRegMailBoxRelease
@ kVRegMailBoxRelease
Definition: ntv2virtualregisters.h:414
NTV2_FORMAT_3840x2160p_2400
@ NTV2_FORMAT_3840x2160p_2400
Definition: ntv2enums.h:638
NTV2_FORMAT_1080p_2400
@ NTV2_FORMAT_1080p_2400
Definition: ntv2enums.h:552
NTV2_FORMAT_1080i_6000
@ NTV2_FORMAT_1080i_6000
Definition: ntv2enums.h:543
CNTV2Card::GetSDIInput3GbPresent
virtual bool GetSDIInput3GbPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3678
kRegCh2Control2MFrame
@ kRegCh2Control2MFrame
Definition: ntv2publicinterface.h:695
kRegMixer3Coefficient
@ kRegMixer3Coefficient
Definition: ntv2publicinterface.h:677
kRegShiftSDIIn6LevelBtoLevelA
@ kRegShiftSDIIn6LevelBtoLevelA
Definition: ntv2publicinterface.h:3082
kRegRP188InOut8Bits0_31
@ kRegRP188InOut8Bits0_31
Definition: ntv2publicinterface.h:611
CNTV2Card::GetMixerCoefficient
virtual bool GetMixerCoefficient(const UWord inWhichMixer, ULWord &outMixCoefficient)
Returns the current mix coefficient the given mixer/keyer.
Definition: ntv2register.cpp:3017
kRegShiftSDIIn83GbpsMode
@ kRegShiftSDIIn83GbpsMode
Definition: ntv2publicinterface.h:3094
CNTV2Card::GetTransmitSDIs
virtual bool GetTransmitSDIs(NTV2ChannelSet &outXmitSDIs)
Answers with the transmitting/output SDI connectors.
Definition: ntv2register.cpp:3893
kRegShiftRGBLevelA
@ kRegShiftRGBLevelA
Definition: ntv2publicinterface.h:2760
kRegShiftFramePulseEnable
@ kRegShiftFramePulseEnable
Definition: ntv2publicinterface.h:2382
kRegShiftMRStandard
@ kRegShiftMRStandard
Definition: ntv2publicinterface.h:3341
hr
__out HRESULT & hr
Definition: pstream.cpp:145
kRegMaskSDIIn412GbpsMode
@ kRegMaskSDIIn412GbpsMode
Definition: ntv2publicinterface.h:2006
NTV2FBOrientation
enum NTV2VideoFrameBufferOrientation NTV2FBOrientation
kDeviceCanDoMultiFormat
@ kDeviceCanDoMultiFormat
True if device can simultaneously handle different video formats on more than one SDI input or output...
Definition: ntv2devicefeatures.h:71
kRegMaskAnalogCompositeFormat625
@ kRegMaskAnalogCompositeFormat625
Definition: ntv2publicinterface.h:1583
kRegSDIOut8Control
@ kRegSDIOut8Control
Definition: ntv2publicinterface.h:666
CNTV2Card::SetSDIOutLevelAtoLevelBConversion
virtual bool SetSDIOutLevelAtoLevelBConversion(const UWord inOutputSpigot, const bool inEnable)
Enables or disables 3G level A to 3G level B conversion at the SDI output widget (assuming the AJA de...
Definition: ntv2register.cpp:4365
NTV2_STANDARD_3840i
@ NTV2_STANDARD_3840i
Identifies Ultra-High-Definition (UHD) psf.
Definition: ntv2enums.h:175
kRegBitfileTime
@ kRegBitfileTime
Definition: ntv2publicinterface.h:212
kRegShiftSDIIn212GbpsMode
@ kRegShiftSDIIn212GbpsMode
Definition: ntv2publicinterface.h:3053
kRegShiftRP188Source
@ kRegShiftRP188Source
Definition: ntv2publicinterface.h:2523
CNTV2Card::BankSelectWriteRegister
virtual bool BankSelectWriteRegister(const NTV2RegInfo &inBankSelect, const NTV2RegInfo &inRegInfo)
Writes the given set of registers to the bank specified at position 0.
Definition: ntv2register.cpp:4669
debug.h
Declares the AJADebug class.
kRegShiftRP188ModeCh6
@ kRegShiftRP188ModeCh6
Definition: ntv2publicinterface.h:2372
NTV2_FORMAT_3840x2160p_3000
@ NTV2_FORMAT_3840x2160p_3000
Definition: ntv2enums.h:641
kRegMaskSDIIn66GbpsMode
@ kRegMaskSDIIn66GbpsMode
Definition: ntv2publicinterface.h:2021
kRegShiftSDIInCRCErrorCountA
@ kRegShiftSDIInCRCErrorCountA
Definition: ntv2publicinterface.h:3184
NTV2_FORMAT_1080psf_2400
@ NTV2_FORMAT_1080psf_2400
Definition: ntv2enums.h:547
kDeviceGetNumLTCOutputs
@ kDeviceGetNumLTCOutputs
The number of analog LTC outputs on the device.
Definition: ntv2devicefeatures.h:217
kRegShiftInput1Progressive
@ kRegShiftInput1Progressive
Definition: ntv2publicinterface.h:2506
CNTV2Card::SetVideoVOffset
virtual bool SetVideoVOffset(const int inVOffset, const UWord inOutputSpigot=0)
Adjusts the vertical timing offset, in lines, for the given SDI output connector.
Definition: ntv2register.cpp:723
NTV2_IS_PROGRESSIVE_STANDARD
#define NTV2_IS_PROGRESSIVE_STANDARD(__s__)
Definition: ntv2enums.h:183
kRegRP188InOut6DBB
@ kRegRP188InOut6DBB
Definition: ntv2publicinterface.h:593
kRegMaskSDIIn6LevelBtoLevelA
@ kRegMaskSDIIn6LevelBtoLevelA
Definition: ntv2publicinterface.h:2018
CNTV2Card::GetAlphaFromInput2Bit
virtual bool GetAlphaFromInput2Bit(ULWord &outValue)
Definition: ntv2register.cpp:2292
NTV2_FORMAT_4096x2160p_5994
@ NTV2_FORMAT_4096x2160p_5994
Definition: ntv2enums.h:665
kRegShiftVidProcFGMatteEnable
@ kRegShiftVidProcFGMatteEnable
Definition: ntv2publicinterface.h:2437
kRegCh3InputFrame
@ kRegCh3InputFrame
Definition: ntv2publicinterface.h:400
CNTV2Card::ReadLineCount
virtual bool ReadLineCount(ULWord &outValue)
Answers with the line offset into the frame currently being read (NTV2_MODE_DISPLAY) or written (NTV2...
Definition: ntv2register.cpp:2294
NTV2_RP188Mode
NTV2_RP188Mode
Definition: ntv2enums.h:2084
kDeviceGetNumLTCInputs
@ kDeviceGetNumLTCInputs
The number of analog LTC inputs on the device.
Definition: ntv2devicefeatures.h:216
NTV2InputVideoSelect
NTV2InputVideoSelect
Definition: ntv2enums.h:2285
NTV2_REFERENCE_SFP1_PCR
@ NTV2_REFERENCE_SFP1_PCR
Specifies the PCR source on SFP 1.
Definition: ntv2enums.h:1458
kRegMaskQuarterSizeMode
@ kRegMaskQuarterSizeMode
Definition: ntv2publicinterface.h:1312
kRegShiftDualLinKOutput
@ kRegShiftDualLinKOutput
Definition: ntv2publicinterface.h:2340
CNTV2Card::GetFrameBufferOrientation
virtual bool GetFrameBufferOrientation(const NTV2Channel inChannel, NTV2FBOrientation &outValue)
Answers with the current frame buffer orientation for the given NTV2Channel.
Definition: ntv2register.cpp:2043
kRegGlobalControl
@ kRegGlobalControl
Definition: ntv2publicinterface.h:120
kRegMaskRS422ParitySense
@ kRegMaskRS422ParitySense
Definition: ntv2publicinterface.h:1497
NTV2VideoDACMode
NTV2VideoDACMode
Definition: ntv2enums.h:2131
NTV2_FORMAT_4x2048x1080psf_2997
@ NTV2_FORMAT_4x2048x1080psf_2997
Definition: ntv2enums.h:606
kRegRP188InOut8DBB
@ kRegRP188InOut8DBB
Definition: ntv2publicinterface.h:613
kRegMaskVidProcFGMatteEnable
@ kRegMaskVidProcFGMatteEnable
Definition: ntv2publicinterface.h:1345
gChannelToSDIIn12GModeMask
static const ULWord gChannelToSDIIn12GModeMask[]
Definition: ntv2register.cpp:143
NTV2_VIDEOLIMITING_OFF
@ NTV2_VIDEOLIMITING_OFF
Disables normal FrameBuffer Y/C value read limiting (NOT RECOMMENDED).
Definition: ntv2enums.h:3759
kRegMaskSDIIn83GbpsSMPTELevelBMode
@ kRegMaskSDIIn83GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2031
NTV2_AUDIOSYSTEM_INVALID
@ NTV2_AUDIOSYSTEM_INVALID
Definition: ntv2enums.h:3885
NTV2_FORMAT_1080p_2K_2997
@ NTV2_FORMAT_1080p_2K_2997
Definition: ntv2enums.h:622
kRegShiftFrameOrientation
@ kRegShiftFrameOrientation
Definition: ntv2publicinterface.h:2402
CNTV2Card::GetFrameBufferQuality
virtual bool GetFrameBufferQuality(NTV2Channel inChannel, NTV2FrameBufferQuality &outValue)
Definition: ntv2register.cpp:1991
gChannelToRP188ModeGCRegisterNum
static const ULWord gChannelToRP188ModeGCRegisterNum[]
Definition: ntv2register.cpp:109