AJA NTV2 SDK  18.0.0.2717
NTV2 SDK 18.0.0.2717
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: NTV2TaskMode
178 // Output: NONE
179 bool CNTV2Card::SetTaskMode (const NTV2TaskMode inMode)
180 {
181  return NTV2_IS_VALID_TASK_MODE(inMode) && WriteRegister(kVRegEveryFrameTaskFilter, ULWord(inMode));
182 }
183 
184 bool CNTV2Card::GetTaskMode (NTV2TaskMode & outMode)
185 {
186  return driverInterface().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  NTV2TaskMode mode;
209  GetTaskMode(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  NTV2TaskMode mode;
901  GetTaskMode(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::GetLargestFrameBufferFormatInUse(NTV2FrameBufferFormat & outFBF)
1757 {
1758  NTV2FrameBufferFormat ch1format;
1759  NTV2FrameBufferFormat ch2format = NTV2_FBF_8BIT_YCBCR;
1760 
1761  if ( !GetFrameBufferFormat(NTV2_CHANNEL1, ch1format) )
1762  return false;
1763 
1764  if ( !GetFrameBufferFormat(NTV2_CHANNEL2, ch2format) &&
1765  GetNumSupported(kDeviceGetNumVideoChannels) > 1)
1766  return false;
1767 
1768  NTV2FrameGeometry geometry;
1769  if (!GetFrameGeometry(geometry))
1770  return false;
1771 
1772  ULWord ch1FrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,ch1format);
1773  ULWord ch2FrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,geometry,ch2format);
1774  if ( ch1FrameBufferSize >= ch2FrameBufferSize )
1775  outFBF = ch1format;
1776  else
1777  outFBF = ch2format;
1778  return true;
1779 }
1780 
1781 bool CNTV2Card::IsMultiFormatActive (void)
1782 {
1783  if (!IsSupported(kDeviceCanDoMultiFormat))
1784  return false;
1785 
1786  bool isEnabled = false;
1787  if (!GetMultiFormatMode (isEnabled))
1788  return false;
1789 
1790  return isEnabled;
1791 }
1792 
1793 bool CNTV2Card::GetPossibleConnections (NTV2PossibleConnections & outConnections)
1794 {
1795  outConnections.clear();
1796  if (!IsSupported(kDeviceHasXptConnectROM))
1797  return false;
1798 
1799  NTV2RegReads ROMregs;
1800  return CNTV2SignalRouter::MakeRouteROMRegisters(ROMregs)
1801  && ReadRegisters(ROMregs)
1802  && CNTV2SignalRouter::GetPossibleConnections(ROMregs, outConnections);
1803 }
1804 
1805 bool CNTV2Card::GetAllWidgetInputs (NTV2InputXptIDSet & outInputs)
1806 {
1807  outInputs.clear();
1808  const ULWordSet widgetIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
1809 
1810  for (ULWordSetConstIter iter(widgetIDs.begin()); iter != widgetIDs.end (); ++iter)
1811  {
1812  const NTV2WidgetID wgtID(NTV2WidgetID(*iter + 0));
1813  NTV2InputXptIDSet inputs;
1814  CNTV2SignalRouter::GetWidgetInputs (wgtID, inputs);
1815  for (NTV2InputXptIDSetConstIter it(inputs.begin()); it != inputs.end(); ++it)
1816  {
1817  if (CNTV2SignalRouter::WidgetIDToType(wgtID) == NTV2WidgetType_FrameStore)
1818  if (!IsSupported(kDeviceCanDo425Mux))
1819  if (!IsSupported(kDeviceCanDo8KVideo))
1820  if (::NTV2InputCrosspointIDToString(*it, false).find("DS2") != string::npos) // is DS2 input?
1821  continue; // do not include FrameStore DS2 inputs for IP25G
1822  outInputs.insert(*it);
1823  }
1824  }
1825  return true;
1826 }
1827 
1828 bool CNTV2Card::GetAllWidgetOutputs (NTV2OutputXptIDSet & outOutputs)
1829 {
1830  outOutputs.clear();
1831  const ULWordSet widgetIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
1832 
1833  for (ULWordSetConstIter iter(widgetIDs.begin()); iter != widgetIDs.end (); ++iter)
1834  {
1835  const NTV2WidgetID wgtID(NTV2WidgetID(*iter + 0));
1836  NTV2OutputXptIDSet outputs;
1837  CNTV2SignalRouter::GetWidgetOutputs (wgtID, outputs);
1838  for (NTV2OutputXptIDSetConstIter it(outputs.begin()); it != outputs.end(); ++it)
1839  {
1840  if (CNTV2SignalRouter::WidgetIDToType(wgtID) == NTV2WidgetType_FrameStore)
1841  if (!IsSupported(kDeviceCanDo425Mux))
1842  if (!IsSupported(kDeviceCanDo8KVideo))
1843  if (::NTV2OutputCrosspointIDToString(*it, false).find("DS2") != string::npos) // is DS2 output?
1844  continue; // do not include FrameStore DS2 outputs for IP25G
1845  outOutputs.insert(*it);
1846  }
1847  }
1848  return true;
1849 }
1850 
1852 
1853 // Method: SetFrameBufferFormat
1854 // Input: NTV2Channel, NTV2FrameBufferFormat
1855 // Output: NONE
1856 bool CNTV2Card::SetFrameBufferFormat (NTV2Channel inChannel, NTV2FrameBufferFormat inNewFormat, bool inIsRetailMode,
1857  NTV2HDRXferChars inXferChars, NTV2HDRColorimetry inColorimetry, NTV2HDRLuminance inLuminance)
1858 { (void) inIsRetailMode;
1859 
1860  if (IsMultiRasterWidgetChannel(inChannel))
1861  return inNewFormat == NTV2_FBF_8BIT_YCBCR;
1862  if (IS_CHANNEL_INVALID(inChannel))
1863  return false;
1864 
1865  const ULWord regNum (gChannelToControlRegNum[inChannel]);
1866  const ULWord loValue (inNewFormat & 0x0f);
1867  const ULWord hiValue ((inNewFormat & 0x10) >> 4);
1868  NTV2FrameGeometry currentGeometry (NTV2_FG_INVALID);
1869  NTV2FrameBufferFormat currentFormat (NTV2_FBF_INVALID); // save for call to IsBufferSizeChangeRequired below
1870  bool status = GetFrameInfo(inChannel, currentGeometry, currentFormat);
1871  if (!status)
1872  return status;
1873 
1874  // Set channel control register FBF bits 1,2,3,4,6...
1875  status = WriteRegister (regNum, loValue, kRegMaskFrameFormat, kRegShiftFrameFormat)
1876  && WriteRegister (regNum, hiValue, kRegMaskFrameFormatHiBit, kRegShiftFrameFormatHiBit);
1877 
1878  // If software set the frame buffer size, read the values from hardware
1879  if ( !GetFBSizeAndCountFromHW(_ulFrameBufferSize, _ulNumFrameBuffers) &&
1880  IsBufferSizeChangeRequired(inChannel, currentGeometry, currentFormat, inNewFormat) )
1881  {
1882  _ulFrameBufferSize = ::NTV2DeviceGetFrameBufferSize(_boardID,currentGeometry, inNewFormat);
1883  _ulNumFrameBuffers = ::NTV2DeviceGetNumberFrameBuffers(_boardID,currentGeometry, inNewFormat);
1884  }
1885 
1886  if (status)
1887  {if (inNewFormat != currentFormat)
1888  CVIDINFO("'" << GetDisplayName() << "': Channel " << DEC(UWord(inChannel)+1) << " FBF changed from "
1889  << ::NTV2FrameBufferFormatToString(currentFormat) << " to "
1890  << ::NTV2FrameBufferFormatToString(inNewFormat) << " (FBSize=" << xHEX0N(_ulFrameBufferSize,8)
1891  << " numFBs=" << DEC(_ulNumFrameBuffers) << ")");}
1892  else
1893  CVIDFAIL("'" << GetDisplayName() << "': Failed to change channel " << DEC(UWord(inChannel)+1) << " FBF from "
1894  << ::NTV2FrameBufferFormatToString(currentFormat) << " to " << ::NTV2FrameBufferFormatToString(inNewFormat));
1895 
1896  SetVPIDTransferCharacteristics(inXferChars, inChannel);
1897  SetVPIDColorimetry(inColorimetry, inChannel);
1898  SetVPIDLuminance(inLuminance, inChannel);
1899  return status;
1900 }
1901 
1902 bool CNTV2Card::SetFrameBufferFormat (const NTV2ChannelSet & inFrameStores,
1903  const NTV2FrameBufferFormat inNewFormat,
1904  const bool inIsAJARetail,
1905  const NTV2HDRXferChars inXferChars,
1906  const NTV2HDRColorimetry inColorimetry,
1907  const NTV2HDRLuminance inLuminance)
1908 {
1909  UWord failures(0);
1910  for (NTV2ChannelSetConstIter it(inFrameStores.begin()); it != inFrameStores.end(); ++it)
1911  if (!SetFrameBufferFormat (*it, inNewFormat, inIsAJARetail, inXferChars, inColorimetry, inLuminance))
1912  failures++;
1913  return failures == 0;
1914 }
1915 
1916 // Method: GetFrameBufferFormat
1917 // Input: NTV2Channel
1918 // Output: NTV2FrameBufferFormat
1919 bool CNTV2Card::GetFrameBufferFormat (NTV2Channel inChannel, NTV2FrameBufferFormat & outValue)
1920 {
1921  if (IsMultiRasterWidgetChannel(inChannel))
1922  {outValue = NTV2_FBF_8BIT_YCBCR; return true;}
1923  if (IS_CHANNEL_INVALID (inChannel))
1924  return false;
1925 
1926  ULWord returnVal1, returnVal2;
1927  bool result1 = ReadRegister (gChannelToControlRegNum[inChannel], returnVal1, kRegMaskFrameFormat, kRegShiftFrameFormat);
1928  bool result2 = ReadRegister (gChannelToControlRegNum[inChannel], returnVal2, kRegMaskFrameFormatHiBit, kRegShiftFrameFormatHiBit);
1929 
1930  outValue = NTV2FrameBufferFormat((returnVal1 & 0x0f) | ((returnVal2 & 0x1) << 4));
1931  return result1 && result2;
1932 }
1933 
1934 // Method: SetFrameBufferQuarterSizeMode
1935 // Input: NTV2Channel, NTV2K2QuarterSizeExpandMode
1936 // Output: NONE
1937 bool CNTV2Card::SetFrameBufferQuarterSizeMode (NTV2Channel channel, NTV2QuarterSizeExpandMode value)
1938 {
1939  if (IS_CHANNEL_INVALID (channel))
1940  return false;
1941  return WriteRegister (gChannelToControlRegNum [channel], value, kRegMaskQuarterSizeMode, kRegShiftQuarterSizeMode);
1942 }
1943 
1944 // Method: GetFrameBufferQuarterSizeMode
1945 // Input: NTV2Channel
1946 // Output: NTV2K2QuarterSizeExpandMode
1947 bool CNTV2Card::GetFrameBufferQuarterSizeMode (NTV2Channel inChannel, NTV2QuarterSizeExpandMode & outValue)
1948 {
1949  if (IS_CHANNEL_INVALID (inChannel))
1950  return false;
1951  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskQuarterSizeMode, kRegShiftQuarterSizeMode);
1952 }
1953 
1954 // Method: SetFrameBufferQuality - currently used for ProRes compressed buffers
1955 // Input: NTV2Channel, NTV2K2FrameBufferQuality
1956 // Output: NONE
1957 bool CNTV2Card::SetFrameBufferQuality (NTV2Channel channel, NTV2FrameBufferQuality quality)
1958 {
1959  if (IS_CHANNEL_INVALID (channel))
1960  return false;
1961  // note buffer quality is split between bit 17 (lo), 25-26 (hi)
1962  ULWord loValue = quality & 0x1;
1963  ULWord hiValue = (quality >> 1) & 0x3;
1964  return WriteRegister (gChannelToControlRegNum [channel], loValue, kRegMaskQuality, kRegShiftQuality) &&
1965  WriteRegister (gChannelToControlRegNum [channel], hiValue, kRegMaskQuality2, kRegShiftQuality2);
1966 }
1967 
1968 // Method: GetFrameBufferQuality - currently used for ProRes compressed buffers
1969 // Input: NTV2Channel
1970 // Output: NTV2K2FrameBufferQuality
1971 bool CNTV2Card::GetFrameBufferQuality (NTV2Channel inChannel, NTV2FrameBufferQuality & outQuality)
1972 {
1973  if (IS_CHANNEL_INVALID (inChannel))
1974  return false;
1975  outQuality = NTV2_FBQualityInvalid;
1976  // note buffer quality is split between bit 17 (lo), 25-26 (hi)
1977  ULWord loValue(0), hiValue(0);
1978  if (ReadRegister (gChannelToControlRegNum [inChannel], loValue, kRegMaskQuality, kRegShiftQuality) &&
1979  ReadRegister (gChannelToControlRegNum [inChannel], hiValue, kRegMaskQuality2, kRegShiftQuality2))
1980  {
1981  outQuality = NTV2FrameBufferQuality(loValue + ((hiValue & 0x3) << 1));
1982  return true;
1983  }
1984  return false;
1985 }
1986 
1987 
1988 // Method: SetEncodeAsPSF - currently used for ProRes compressed buffers
1989 // Input: NTV2Channel, NTV2K2FrameBufferQuality
1990 // Output: NONE
1991 bool CNTV2Card::SetEncodeAsPSF(NTV2Channel channel, NTV2EncodeAsPSF value)
1992 {
1993  if (IS_CHANNEL_INVALID (channel))
1994  return false;
1995  return WriteRegister (gChannelToControlRegNum [channel], value, kRegMaskEncodeAsPSF, kRegShiftEncodeAsPSF);
1996 }
1997 
1998 // Method: GetEncodeAsPSF - currently used for ProRes compressed buffers
1999 // Input: NTV2Channel
2000 // Output: NTV2K2FrameBufferQuality
2001 bool CNTV2Card::GetEncodeAsPSF (NTV2Channel inChannel, NTV2EncodeAsPSF & outValue)
2002 {
2003  if (IS_CHANNEL_INVALID (inChannel))
2004  return false;
2005  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskEncodeAsPSF, kRegShiftEncodeAsPSF);
2006 }
2007 
2008 // Method: SetFrameBufferOrientation
2009 // Input: NTV2Channel, NTV2VideoFrameBufferOrientation
2010 // Output: NONE
2011 bool CNTV2Card::SetFrameBufferOrientation (const NTV2Channel inChannel, const NTV2FBOrientation inValue)
2012 {
2013  if (IsMultiRasterWidgetChannel(inChannel))
2014  return inValue == NTV2_FRAMEBUFFER_ORIENTATION_NORMAL;
2015  if (IS_CHANNEL_INVALID(inChannel))
2016  return false;
2017  return WriteRegister (gChannelToControlRegNum[inChannel], inValue, kRegMaskFrameOrientation, kRegShiftFrameOrientation);
2018 }
2019 
2020 // Method: GetFrameBufferOrientation
2021 // Input: NTV2Channel
2022 // Output: NTV2VideoFrameBufferOrientation
2023 bool CNTV2Card::GetFrameBufferOrientation (const NTV2Channel inChannel, NTV2FBOrientation & outValue)
2024 {
2025  if (IsMultiRasterWidgetChannel(inChannel))
2026  {outValue = NTV2_FRAMEBUFFER_ORIENTATION_NORMAL; return true;}
2027  if (IS_CHANNEL_INVALID (inChannel))
2028  return false;
2029  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskFrameOrientation, kRegShiftFrameOrientation);
2030 }
2031 
2032 
2033 bool CNTV2Card::SetFrameBufferSize (const NTV2Framesize inSize)
2034 {
2035  ULWord swCanChgFBSize(0);
2036  if (!GetBoolParam(kDeviceSoftwareCanChangeFrameBufferSize, swCanChgFBSize) || !swCanChgFBSize)
2037  return false;
2038 
2039  ULWord reg1Contents(0);
2040  if (!ReadRegister(kRegCh1Control, reg1Contents))
2041  return false;
2042 
2043  reg1Contents |= kRegMaskFrameSizeSetBySW;
2044  reg1Contents &= ~kK2RegMaskFrameSize;
2045  reg1Contents |= ULWord(inSize) << kK2RegShiftFrameSize;
2046  if (!WriteRegister(kRegCh1Control, reg1Contents))
2047  return false;
2048 
2049  return GetFBSizeAndCountFromHW(_ulFrameBufferSize, _ulNumFrameBuffers);
2050 }
2051 
2052 // Method: SetFrameBufferSize
2053 // Input: NTV2Channel, NTV2K2Framesize
2054 // Output: NONE
2055 bool CNTV2Card::SetFrameBufferSize (const NTV2Channel inChannel, const NTV2Framesize inValue)
2056 {
2057  if (IS_CHANNEL_INVALID(inChannel))
2058  return false;
2059 #if defined (NTV2_ALLOW_2MB_FRAMES)
2060  ULWord supports2m (0);
2061  ReadRegister(kRegGlobalControl2, &supports2m, kRegMask2MFrameSupport, kRegShift2MFrameSupport);
2062  if(supports2m == 1)
2063  {
2064  ULWord value2M (0);
2065  switch(inValue)
2066  {
2067  case NTV2_FRAMESIZE_2MB: value2M = 1; break;
2068  case NTV2_FRAMESIZE_4MB: value2M = 2; break;
2069  case NTV2_FRAMESIZE_6MB: value2M = 3; break;
2070  case NTV2_FRAMESIZE_8MB: value2M = 4; break;
2071  case NTV2_FRAMESIZE_10MB: value2M = 5; break;
2072  case NTV2_FRAMESIZE_12MB: value2M = 6; break;
2073  case NTV2_FRAMESIZE_14MB: value2M = 7; break;
2074  case NTV2_FRAMESIZE_16MB: value2M = 8; break;
2075  case NTV2_FRAMESIZE_18MB: value2M = 9; break;
2076  case NTV2_FRAMESIZE_20MB: value2M = 10; break;
2077  case NTV2_FRAMESIZE_22MB: value2M = 11; break;
2078  case NTV2_FRAMESIZE_24MB: value2M = 12; break;
2079  case NTV2_FRAMESIZE_26MB: value2M = 13; break;
2080  case NTV2_FRAMESIZE_28MB: value2M = 14; break;
2081  case NTV2_FRAMESIZE_30MB: value2M = 15; break;
2082  case NTV2_FRAMESIZE_32MB: value2M = 16; break;
2083  default: return false;
2084  }
2085  return WriteRegister(gChannelTo2MFrame [NTV2_CHANNEL1], value2M, kRegMask2MFrameSize, kRegShift2MFrameSupport);
2086  }
2087  else
2088 #endif // defined (NTV2_ALLOW_2MB_FRAMES)
2089  if (inValue == NTV2_FRAMESIZE_2MB || inValue == NTV2_FRAMESIZE_4MB || inValue == NTV2_FRAMESIZE_8MB || inValue == NTV2_FRAMESIZE_16MB)
2090  return WriteRegister (gChannelToControlRegNum [NTV2_CHANNEL1], inValue, kK2RegMaskFrameSize, kK2RegShiftFrameSize);
2091  return false;
2092 }
2093 
2094 // Method: GetK2FrameBufferSize
2095 // Input: NTV2Channel
2096 // Output: NTV2K2Framesize
2097 bool CNTV2Card::GetFrameBufferSize (const NTV2Channel inChannel, NTV2Framesize & outValue)
2098 {
2099  outValue = NTV2_FRAMESIZE_INVALID;
2100  if (!NTV2_IS_VALID_CHANNEL (inChannel))
2101  return false;
2102 #if defined (NTV2_ALLOW_2MB_FRAMES)
2103  ULWord supports2m (0);
2104  ReadRegister(kRegGlobalControl2, &supports2m, kRegMask2MFrameSupport, kRegShift2MFrameSupport);
2105  if(supports2m == 1)
2106  {
2107  ULWord frameSize (0);
2108  ReadRegister(gChannelTo2MFrame[inChannel], &frameSize, kRegMask2MFrameSize, kRegShift2MFrameSize);
2109  if (frameSize)
2110  {
2111  switch (frameSize)
2112  {
2113  case 1: outValue = NTV2_FRAMESIZE_2MB; break;
2114  case 2: outValue = NTV2_FRAMESIZE_4MB; break;
2115  case 3: outValue = NTV2_FRAMESIZE_6MB; break;
2116  case 4: outValue = NTV2_FRAMESIZE_8MB; break;
2117  case 5: outValue = NTV2_FRAMESIZE_10MB; break;
2118  case 6: outValue = NTV2_FRAMESIZE_12MB; break;
2119  case 7: outValue = NTV2_FRAMESIZE_14MB; break;
2120  case 8: outValue = NTV2_FRAMESIZE_16MB; break;
2121  case 9: outValue = NTV2_FRAMESIZE_18MB; break;
2122  case 10: outValue = NTV2_FRAMESIZE_20MB; break;
2123  case 11: outValue = NTV2_FRAMESIZE_22MB; break;
2124  case 12: outValue = NTV2_FRAMESIZE_24MB; break;
2125  case 13: outValue = NTV2_FRAMESIZE_26MB; break;
2126  case 14: outValue = NTV2_FRAMESIZE_28MB; break;
2127  case 15: outValue = NTV2_FRAMESIZE_30MB; break;
2128  case 16: outValue = NTV2_FRAMESIZE_32MB; break;
2129  default: return false;
2130  }
2131  NTV2_ASSERT (NTV2_IS_8MB_OR_16MB_FRAMESIZE(outValue));
2132  return true;
2133  }
2134  }
2135 #endif // defined (NTV2_ALLOW_2MB_FRAMES)
2136  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[NTV2_CHANNEL1], outValue, kK2RegMaskFrameSize, kK2RegShiftFrameSize);
2137 }
2138 
2139 
2140 bool CNTV2Card::DisableChannel (const NTV2Channel inChannel)
2141 {
2142  if (IsMultiRasterWidgetChannel(inChannel))
2143  return SetMultiRasterBypassEnable(false);
2144  return NTV2_IS_VALID_CHANNEL(inChannel)
2145  && WriteRegister (gChannelToControlRegNum [inChannel], ULWord (true), kRegMaskChannelDisable, kRegShiftChannelDisable);
2146 
2147 } // DisableChannel
2148 
2149 
2150 bool CNTV2Card::DisableChannels (const NTV2ChannelSet & inChannels)
2151 { UWord failures(0);
2152  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2153  if (!DisableChannel(*it))
2154  failures++;
2155  return !failures;
2156 
2157 } // DisableChannels
2158 
2159 
2160 bool CNTV2Card::EnableChannel (const NTV2Channel inChannel)
2161 {
2162  if (IsMultiRasterWidgetChannel(inChannel))
2163  return SetMultiRasterBypassEnable(true);
2164  return NTV2_IS_VALID_CHANNEL(inChannel)
2165  && WriteRegister (gChannelToControlRegNum[inChannel], ULWord(false), kRegMaskChannelDisable, kRegShiftChannelDisable);
2166 
2167 } // EnableChannel
2168 
2169 
2170 bool CNTV2Card::EnableChannels (const NTV2ChannelSet & inChannels, const bool inDisableOthers)
2171 { UWord failures(0);
2172  for (NTV2Channel chan(NTV2_CHANNEL1); chan < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); chan = NTV2Channel(chan+1))
2173  if (inChannels.find(chan) != inChannels.end())
2174  {
2175  if (!EnableChannel(chan))
2176  failures++;
2177  }
2178  else if (inDisableOthers)
2179  DisableChannel(chan);
2180  return !failures;
2181 
2182 } // EnableChannels
2183 
2184 
2185 bool CNTV2Card::IsChannelEnabled (const NTV2Channel inChannel, bool & outEnabled)
2186 {
2187  bool disabled (false);
2188  if (IsMultiRasterWidgetChannel(inChannel))
2189  return GetMultiRasterBypassEnable(outEnabled);
2190  if (IS_CHANNEL_INVALID(inChannel))
2191  return false;
2192  if (!CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], disabled, kRegMaskChannelDisable, kRegShiftChannelDisable))
2193  return false;
2194  outEnabled = disabled ? false : true;
2195  return true;
2196 } // IsChannelEnabled
2197 
2198 
2199 bool CNTV2Card::GetEnabledChannels (NTV2ChannelSet & outChannels)
2200 {
2201  UWord failures(0);
2202  bool enabled(false);
2203  outChannels.clear();
2204  for (NTV2Channel ch(NTV2_CHANNEL1); ch < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); ch = NTV2Channel(ch+1))
2205  if (!IsChannelEnabled (ch, enabled))
2206  failures++;
2207  else if (enabled)
2208  outChannels.insert(ch);
2209  return !failures;
2210 }
2211 
2212 
2213 bool CNTV2Card::GetDisabledChannels (NTV2ChannelSet & outChannels)
2214 {
2215  UWord failures(0);
2216  bool enabled(false);
2217  outChannels.clear();
2218  for (NTV2Channel ch(NTV2_CHANNEL1); ch < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); ch = NTV2Channel(ch+1))
2219  if (!IsChannelEnabled (ch, enabled))
2220  failures++;
2221  else if (!enabled)
2222  outChannels.insert(ch);
2223  return !failures;
2224 }
2225 
2226 #if !defined(NTV2_DEPRECATE_16_2)
2227  bool CNTV2Card::SetPCIAccessFrame (const NTV2Channel inChannel, const ULWord inValue, const bool inWaitForVBI)
2228  {
2229  if (IS_CHANNEL_INVALID(inChannel))
2230  return false;
2231  const bool result (WriteRegister (gChannelToPCIAccessFrameRegNum[inChannel], inValue));
2232  if (inWaitForVBI)
2233  WaitForOutputVerticalInterrupt (inChannel);
2234  return result;
2235  }
2236 
2237  bool CNTV2Card::GetPCIAccessFrame (const NTV2Channel inChannel, ULWord & outValue)
2238  {
2239  return !IS_CHANNEL_INVALID(inChannel)
2240  && ReadRegister (gChannelToPCIAccessFrameRegNum[inChannel], outValue);
2241  }
2242 
2243  bool CNTV2Card::FlipFlopPage (const NTV2Channel inCh)
2244  {
2245  ULWord nextFrm(0), outFrm(0);
2246  return !IS_CHANNEL_INVALID(inCh)
2247  && ReadRegister(gChannelToPCIAccessFrameRegNum[inCh], nextFrm) // GetPCIAccessFrame(inCh, nextFrm)
2248  && GetOutputFrame(inCh, outFrm)
2249  && SetOutputFrame(inCh, nextFrm)
2250  && WriteRegister(gChannelToPCIAccessFrameRegNum[inCh], outFrm) && WaitForOutputVerticalInterrupt(inCh); // SetPCIAccessFrame(inCh, outFrm);
2251  }
2252 #endif // !defined (NTV2_DEPRECATE_16_2)
2253 
2254 bool CNTV2Card::SetOutputFrame (const NTV2Channel inChannel, const ULWord value)
2255 {
2256  if (IsMultiRasterWidgetChannel(inChannel))
2257  return false;
2258  if (IS_CHANNEL_INVALID(inChannel))
2259  return false;
2260  return WriteRegister (gChannelToOutputFrameRegNum [inChannel], value);
2261 }
2262 
2263 bool CNTV2Card::GetOutputFrame (const NTV2Channel inChannel, ULWord & outValue)
2264 {
2265  if (IsMultiRasterWidgetChannel(inChannel))
2266  {outValue = 0; return false;}
2267  if (IS_CHANNEL_INVALID(inChannel))
2268  return false;
2269  return ReadRegister (gChannelToOutputFrameRegNum [inChannel], outValue);
2270 }
2271 
2272 bool CNTV2Card::SetInputFrame (const NTV2Channel inChannel, const ULWord value)
2273 {
2274  if (IsMultiRasterWidgetChannel(inChannel))
2275  return WriteRegister(kRegMROutControl, value, kRegMaskMRFrameLocation, kRegShiftMRFrameLocation);
2276  if (IS_CHANNEL_INVALID(inChannel))
2277  return false;
2278  return WriteRegister (gChannelToInputFrameRegNum [inChannel], value);
2279 }
2280 
2281 bool CNTV2Card::GetInputFrame (const NTV2Channel inChannel, ULWord & outValue)
2282 {
2283  if (IsMultiRasterWidgetChannel(inChannel))
2284  return ReadRegister(kRegMROutControl, outValue, kRegMaskMRFrameLocation, kRegShiftMRFrameLocation);
2285  if (IS_CHANNEL_INVALID(inChannel))
2286  return false;
2287  return ReadRegister (gChannelToInputFrameRegNum[inChannel], outValue);
2288 }
2289 
2290 bool CNTV2Card::SetAlphaFromInput2Bit (ULWord value) {return WriteRegister (kRegCh1Control, value, kRegMaskAlphaFromInput2, kRegShiftAlphaFromInput2);}
2291 bool CNTV2Card::GetAlphaFromInput2Bit (ULWord & outValue) {return ReadRegister (kRegCh1Control, outValue, kRegMaskAlphaFromInput2, kRegShiftAlphaFromInput2);}
2292 
2293 bool CNTV2Card::ReadLineCount (ULWord & outValue)
2294 {
2295  return ReadRegister (kRegLineCount, outValue);
2296 }
2297 
2298 bool CNTV2Card::ReadFlashProgramControl (ULWord & outValue)
2299 {
2300  return ReadRegister (kRegFlashProgramReg, outValue);
2301 }
2302 
2303 
2304 // Determine if Xilinx programmed
2305 // Input: NONE
2306 // Output: ULWord or equivalent(i.e. ULWord).
2307 bool CNTV2Card::IsXilinxProgrammed()
2308 {
2309  ULWord programFlashValue;
2310  if(ReadFlashProgramControl(programFlashValue))
2311  {
2312  if ((programFlashValue & BIT(9)) == BIT(9))
2313  {
2314  return true;
2315  }
2316  }
2317  return false;
2318 }
2319 
2320 bool CNTV2Card::GetProgramStatus(SSC_GET_FIRMWARE_PROGRESS_STRUCT *statusStruct)
2321 {
2322  ULWord totalSize = 0;
2323  ULWord totalProgress = 0;
2324  ULWord state = kProgramStateFinished;
2325  ReadRegister(kVRegFlashSize, totalSize);
2326  ReadRegister(kVRegFlashStatus, totalProgress);
2327  ReadRegister(kVRegFlashState, state);
2328  statusStruct->programTotalSize = totalSize;
2329  statusStruct->programProgress = totalProgress;
2330  statusStruct->programState = ProgramState(state);
2331  return true;
2332 }
2333 
2334 bool CNTV2Card::ProgramMainFlash (const string & inFileName, const bool bInForceUpdate, const bool bInQuiet)
2335 {
2336  CNTV2KonaFlashProgram devFlasher(GetIndexNumber());
2337  if (bInQuiet)
2338  devFlasher.SetQuietMode();
2339  ostringstream msgs;
2340  string progResults;
2341  const bool ok(devFlasher.SetBitFile(inFileName, msgs, MAIN_FLASHBLOCK));
2342  if (bInForceUpdate)
2343  devFlasher.SetMBReset();
2344  if (ok)
2345  progResults = devFlasher.Program(false);
2346  else
2347  {AJA_sERROR(AJA_DebugUnit_UserGeneric, INSTP(this) << "::" << AJAFUNC << ": " << msgs.str()); return false;}
2348  if (!progResults.empty())
2349  AJA_sERROR(AJA_DebugUnit_UserGeneric, INSTP(this) << "::" << AJAFUNC << ": " << progResults);
2350  return progResults.empty();
2351 }
2352 
2353 bool CNTV2Card::GetRunningFirmwarePackageRevision (ULWord & outRevision)
2354 {
2355  outRevision = 0;
2356  if (!IsOpen())
2357  return false; // Not open
2358  if (!IsIPDevice())
2359  return false; // No MicroBlaze
2360  return ReadRegister(kRegSarekPackageVersion + SAREK_REGS, outRevision);
2361 }
2362 
2363 bool CNTV2Card::GetRunningFirmwareRevision (UWord & outRevision)
2364 {
2365  outRevision = 0;
2366  if (!IsOpen())
2367  return false;
2368 
2369  uint32_t regValue (0);
2370  if (!ReadRegister (kRegDMAControl, regValue))
2371  return false;
2372 
2373  outRevision = uint16_t((regValue & 0x0000FF00) >> 8);
2374  return true;
2375 }
2376 
2377 bool CNTV2Card::GetRunningFirmwareDate (UWord & outYear, UWord & outMonth, UWord & outDay)
2378 {
2379  outYear = outMonth = outDay = 0;
2380  if (!IsSupported(kDeviceCanReportRunningFirmwareDate))
2381  return false;
2382 
2383  uint32_t regValue (0);
2384  if (!ReadRegister(kRegBitfileDate, regValue))
2385  return false;
2386 
2387  const UWord yearBCD ((regValue & 0xFFFF0000) >> 16); // Year number in BCD
2388  const UWord monthBCD ((regValue & 0x0000FF00) >> 8); // Month number in BCD
2389  const UWord dayBCD (regValue & 0x000000FF); // Day number in BCD
2390 
2391  outYear = ((yearBCD & 0xF000) >> 12) * 1000
2392  + ((yearBCD & 0x0F00) >> 8) * 100
2393  + ((yearBCD & 0x00F0) >> 4) * 10
2394  + (yearBCD & 0x000F);
2395 
2396  outMonth = ((monthBCD & 0x00F0) >> 4) * 10 + (monthBCD & 0x000F);
2397 
2398  outDay = ((dayBCD & 0x00F0) >> 4) * 10 + (dayBCD & 0x000F);
2399 
2400  return outYear > 2010
2401  && outMonth > 0 && outMonth < 13
2402  && outDay > 0 && outDay < 32; // If the date's valid, then it's supported; otherwise, it ain't
2403 }
2404 
2405 
2406 bool CNTV2Card::GetRunningFirmwareTime (UWord & outHours, UWord & outMinutes, UWord & outSeconds)
2407 {
2408  outHours = outMinutes = outSeconds = 0;
2409  if (!IsSupported(kDeviceCanReportRunningFirmwareDate))
2410  return false;
2411 
2412  uint32_t regValue (0);
2413  if (!ReadRegister(kRegBitfileTime, regValue))
2414  return false;
2415 
2416  const UWord hoursBCD ((regValue & 0x00FF0000) >> 16); // Hours number in BCD
2417  const UWord minutesBCD ((regValue & 0x0000FF00) >> 8); // Minutes number in BCD
2418  const UWord secondsBCD (regValue & 0x000000FF); // Seconds number in BCD
2419 
2420  outHours = ((hoursBCD & 0x00F0) >> 4) * 10 + (hoursBCD & 0x000F);
2421 
2422  outMinutes = ((minutesBCD & 0x00F0) >> 4) * 10 + (minutesBCD & 0x000F);
2423 
2424  outSeconds = ((secondsBCD & 0x00F0) >> 4) * 10 + (secondsBCD & 0x000F);
2425 
2426  return outHours < 24 && outMinutes < 60 && outSeconds < 60; // If the time's valid, then it's supported; otherwise, it ain't
2427 }
2428 
2429 
2430 bool CNTV2Card::GetRunningFirmwareDate (std::string & outDate, std::string & outTime)
2431 {
2432  outDate = outTime = string();
2433  UWord yr(0), mo(0), dy(0), hr(0), mn(0), sec(0);
2434  if (!GetRunningFirmwareDate (yr, mo, dy))
2435  return false;
2436  if (!GetRunningFirmwareTime (hr, mn, sec))
2437  return false;
2438 
2439  ostringstream date, time;
2440  date << DEC0N(yr,4) << "/" << DEC0N(mo,2) << "/" << DEC0N(dy,2);
2441  time << DEC0N(hr,2) << ":" << DEC0N(mn,2) << ":" << DEC0N(sec,2);
2442 
2443  outDate = date.str();
2444  outTime = time.str();
2445  return true;
2446 }
2447 
2448 
2449 bool CNTV2Card::GetRunningFirmwareUserID (ULWord & outUserID)
2450 {
2451  outUserID = 0;
2452  if (!IsOpen())
2453  return false;
2454 
2455  ULWord regValue (0);
2456  if (!ReadRegister (kRegFirmwareUserID, regValue))
2457  return false;
2458 
2459  outUserID = regValue;
2460  return true;
2461 }
2462 
2463 
2465 
2466 bool CNTV2Card::GetPCIDeviceID (ULWord & outPCIDeviceID) {return ReadRegister (kVRegPCIDeviceID, outPCIDeviceID);}
2467 
2468 bool CNTV2Card::SupportsP2PTransfer (void)
2469 {
2470  ULWord pciID (0);
2471 
2472  if (GetPCIDeviceID (pciID))
2473  switch (pciID)
2474  {
2475  case 0xDB07: // Kona3G + P2P
2476  case 0xDB08: // Kona3G Quad + P2P
2477  case 0xEB0B: // Kona4quad
2478  case 0xEB0C: // Kona4ufc
2479  case 0xEB0E: // Corvid 44
2480  case 0xEB0D: // Corvid 88
2481  return true;
2482 
2483  default:
2484  return false;
2485  }
2486  return false;
2487 }
2488 
2489 
2490 bool CNTV2Card::SupportsP2PTarget (void)
2491 {
2492  ULWord pciID (0);
2493 
2494  if (GetPCIDeviceID (pciID))
2495  switch (pciID)
2496  {
2497  case 0xDB07: // Kona3G + P2P
2498  case 0xDB08: // Kona3G Quad + P2P
2499  case 0xEB0C: // Kona4ufc
2500  case 0xEB0E: // Corvid 44
2501  case 0xEB0D: // Corvid 88
2502  return true;
2503 
2504  default:
2505  return false;
2506  }
2507  return false;
2508 }
2509 
2510 
2511 bool CNTV2Card::SetRegisterWriteMode (const NTV2RegisterWriteMode value, const NTV2Channel inFrameStore)
2512 {
2513  bool ret;
2514 
2515  if (IS_CHANNEL_INVALID(inFrameStore))
2516  return false;
2517  if (IsMultiFormatActive())
2518  return WriteRegister (gChannelToGlobalControlRegNum[inFrameStore], value, kRegMaskRegClocking, kRegShiftRegClocking);
2519  if (IsSupported(kDeviceCanDoMultiFormat))
2520  {
2521  for (NTV2Channel chan(NTV2_CHANNEL1); chan < NTV2Channel(GetNumSupported(kDeviceGetNumFrameStores)); chan = NTV2Channel(chan+1))
2522  {
2523  ret = WriteRegister (gChannelToGlobalControlRegNum[chan], value, kRegMaskRegClocking, kRegShiftRegClocking);
2524  if (!ret)
2525  return false;
2526  }
2527  return true;
2528  }
2529  return WriteRegister (gChannelToGlobalControlRegNum[NTV2_CHANNEL1], value, kRegMaskRegClocking, kRegShiftRegClocking);
2530 }
2531 
2532 
2533 bool CNTV2Card::GetRegisterWriteMode (NTV2RegisterWriteMode & outValue, const NTV2Channel inFrameStore)
2534 {
2535  if (IS_CHANNEL_INVALID (inFrameStore))
2536  return false;
2537  ULWord value(0);
2538  if (!ReadRegister(gChannelToGlobalControlRegNum[IsMultiFormatActive() ? inFrameStore : NTV2_CHANNEL1],
2539  value, kRegMaskRegClocking, kRegShiftRegClocking))
2540  return false;
2541  outValue = NTV2RegisterWriteMode(value);
2542  return true;
2543 }
2544 
2545 
2546 bool CNTV2Card::SetLEDState (ULWord value) {return WriteRegister (kRegGlobalControl, value, kRegMaskLED, kRegShiftLED);}
2547 bool CNTV2Card::GetLEDState (ULWord & outValue) {return ReadRegister (kRegGlobalControl, outValue, kRegMaskLED, kRegShiftLED);}
2548 
2549 
2551 // RP188 methods
2553 
2554 bool CNTV2Card::SetRP188Mode (const NTV2Channel inChannel, const NTV2_RP188Mode inValue)
2555 {
2556  if (IS_CHANNEL_INVALID (inChannel))
2557  return false;
2558  return WriteRegister (gChannelToRP188ModeGCRegisterNum [inChannel], inValue, gChannelToRP188ModeMasks [inChannel], gChannelToRP188ModeShifts [inChannel]);
2559 }
2560 
2561 
2562 bool CNTV2Card::GetRP188Mode (const NTV2Channel inChannel, NTV2_RP188Mode & outMode)
2563 {
2564  if (IS_CHANNEL_INVALID (inChannel))
2565  return false;
2566  const bool result (CNTV2DriverInterface::ReadRegister (gChannelToRP188ModeGCRegisterNum[inChannel], outMode, gChannelToRP188ModeMasks[inChannel], gChannelToRP188ModeShifts[inChannel]));
2567  if (!result)
2568  outMode = NTV2_RP188_INVALID;
2569  return result;
2570 }
2571 
2572 
2573 bool CNTV2Card::GetRP188Data (const NTV2Channel inChannel, NTV2_RP188 & outRP188Data)
2574 {
2575  outRP188Data = NTV2_RP188();
2576  if (IS_CHANNEL_INVALID (inChannel))
2577  return false;
2578  return ReadRegister (gChlToRP188DBBRegNum[inChannel], outRP188Data.fDBB, kRegMaskRP188DBB, kRegShiftRP188DBB)
2579  && ReadRegister (gChlToRP188Bits031RegNum[inChannel], outRP188Data.fLo)
2580  && ReadRegister (gChlToRP188Bits3263RegNum[inChannel], outRP188Data.fHi);
2581 }
2582 
2583 
2584 bool CNTV2Card::SetRP188Data (const NTV2Channel inChannel, const NTV2_RP188 & inRP188Data)
2585 {
2586  if (IS_CHANNEL_INVALID (inChannel))
2587  return false;
2588  if (!inRP188Data.IsValid())
2589  return false;
2590  return WriteRegister (gChlToRP188DBBRegNum[inChannel], inRP188Data.fDBB, kRegMaskRP188DBB, kRegShiftRP188DBB)
2591  && WriteRegister (gChlToRP188Bits031RegNum[inChannel], inRP188Data.fLo)
2592  && WriteRegister (gChlToRP188Bits3263RegNum[inChannel], inRP188Data.fHi);
2593 }
2594 
2595 
2596 bool CNTV2Card::SetRP188SourceFilter (const NTV2Channel inChannel, UWord inValue)
2597 {
2598  if (IS_CHANNEL_INVALID (inChannel))
2599  return false;
2600  return WriteRegister (gChlToRP188DBBRegNum[inChannel], ULWord(inValue), kRegMaskRP188SourceSelect, kRegShiftRP188Source);
2601 }
2602 
2603 
2604 bool CNTV2Card::GetRP188SourceFilter (const NTV2Channel inChannel, UWord & outValue)
2605 {
2606  if (IS_CHANNEL_INVALID (inChannel))
2607  return false;
2608  return CNTV2DriverInterface::ReadRegister (gChlToRP188DBBRegNum[inChannel], outValue, kRegMaskRP188SourceSelect, kRegShiftRP188Source);
2609 }
2610 
2611 
2612 bool CNTV2Card::IsRP188BypassEnabled (const NTV2Channel inChannel, bool & outIsBypassEnabled)
2613 {
2614  if (IS_CHANNEL_INVALID (inChannel))
2615  return false;
2616  // Bit 23 of the RP188 DBB register will be set if output timecode will be grabbed directly from an input (bypass source)...
2617  ULWord regValue (0);
2618  bool result (NTV2_IS_VALID_CHANNEL(inChannel) && ReadRegister(gChlToRP188DBBRegNum[inChannel], regValue));
2619  if (result)
2620  outIsBypassEnabled = regValue & BIT(23);
2621  return result;
2622 }
2623 
2624 
2625 bool CNTV2Card::DisableRP188Bypass (const NTV2Channel inChannel)
2626 {
2627  if (IS_CHANNEL_INVALID (inChannel))
2628  return false;
2629  // Clear bit 23 of my output destination's RP188 DBB register...
2630  return NTV2_IS_VALID_CHANNEL (inChannel) && WriteRegister (gChlToRP188DBBRegNum[inChannel], 0, BIT(23), 23);
2631 }
2632 
2633 
2634 bool CNTV2Card::EnableRP188Bypass (const NTV2Channel inChannel)
2635 {
2636  if (IS_CHANNEL_INVALID (inChannel))
2637  return false;
2638  // Set bit 23 of my output destination's RP188 DBB register...
2639  return NTV2_IS_VALID_CHANNEL (inChannel) && WriteRegister (gChlToRP188DBBRegNum [inChannel], 1, BIT(23), 23);
2640 }
2641 
2642 static const ULWord gSDIOutToRP188Input[] = { 0, 2, 1, 3, 0, 2, 1, 3, 0 };
2643 
2644 bool CNTV2Card::SetRP188BypassSource (const NTV2Channel inSDIOutput, const UWord inSDIInput)
2645 {
2646  if (IS_CHANNEL_INVALID(inSDIOutput))
2647  return false;
2648  if (IS_CHANNEL_INVALID(NTV2Channel(inSDIInput)))
2649  return false;
2650  return WriteRegister(gChlToRP188DBBRegNum[inSDIOutput], gSDIOutToRP188Input[inSDIInput], BIT(21)|BIT(22), 21);
2651 }
2652 
2653 bool CNTV2Card::GetRP188BypassSource (const NTV2Channel inSDIOutput, UWord & outSDIInput)
2654 {
2655  if (IS_CHANNEL_INVALID(inSDIOutput))
2656  return false;
2657  ULWord val(0);
2658  if (!ReadRegister(gChlToRP188DBBRegNum[inSDIOutput], val, BIT(21)|BIT(22), 21))
2659  return false;
2660  switch(val)
2661  {
2662  case 0: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 0 : 4; break;
2663  case 2: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 1 : 5; break;
2664  case 1: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 2 : 6; break;
2665  case 3: outSDIInput = inSDIOutput < NTV2_CHANNEL5 ? 3 : 7; break;
2666  default: return false;
2667  }
2668  return true;
2669 }
2670 
2671 
2672 bool CNTV2Card::SetVideoLimiting (const NTV2VideoLimiting inValue)
2673 {
2674  if (!NTV2_IS_VALID_VIDEOLIMITING(inValue))
2675  return false;
2676  CVIDINFO("'" << GetDisplayName() << "' set to " << ::NTV2VideoLimitingToString(inValue));
2677  return WriteRegister (kRegVidProc1Control, inValue, kRegMaskVidProcLimiting, kRegShiftVidProcLimiting);
2678 }
2679 
2680 bool CNTV2Card::GetVideoLimiting (NTV2VideoLimiting & outValue)
2681 {
2682  return CNTV2DriverInterface::ReadRegister (kRegVidProc1Control, outValue, kRegMaskVidProcLimiting, kRegShiftVidProcLimiting);
2683 }
2684 
2685 
2686 //SetEnableVANCData
2687 // Call SetVideoFormat with the desired video format BEFORE you call this function!
2688 bool CNTV2Card::SetEnableVANCData (const bool inVANCenable, const bool inTallerVANC, const NTV2Channel inChannel)
2689 {
2690  return SetVANCMode (NTV2VANCModeFromBools(inVANCenable, inTallerVANC), IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2691 }
2692 
2693 bool CNTV2Card::SetVANCMode (const NTV2ChannelSet & inChannels, const NTV2VANCMode inVancMode)
2694 {
2695  size_t errors(0);
2696  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2697  if (!SetVANCMode (inVancMode, *it))
2698  errors++;
2699  return !errors;
2700 }
2701 
2702 
2703 bool CNTV2Card::SetVANCMode (const NTV2VANCMode inVancMode, const NTV2Channel inChannel)
2704 {
2705  const NTV2Channel ch (IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2706  if (IsMultiRasterWidgetChannel(ch))
2707  return inVancMode == NTV2_VANCMODE_OFF;
2708  if (IS_CHANNEL_INVALID(ch))
2709  return false;
2710  if (!NTV2_IS_VALID_VANCMODE(inVancMode))
2711  return false;
2712 
2713  NTV2FrameGeometry fg(NTV2_FG_INVALID);
2714  NTV2Standard st(NTV2_STANDARD_INVALID);
2715  GetStandard(st, ch);
2716  GetFrameGeometry(fg, ch);
2717  switch (st)
2718  {
2719  case NTV2_STANDARD_1080:
2720  case NTV2_STANDARD_1080p:
2721  if (fg == NTV2_FG_1920x1112 || fg == NTV2_FG_1920x1114 || fg == NTV2_FG_1920x1080)
2722  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_1920x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_1920x1112 : NTV2_FG_1920x1080);
2723  else if (NTV2_IS_QUAD_FRAME_GEOMETRY(fg)) // 4K
2724  ; // do nothing for now
2725  else if (NTV2_IS_2K_1080_FRAME_GEOMETRY(fg)) // 2Kx1080
2726  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_2048x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_2048x1112 : NTV2_FG_2048x1080);
2727  break;
2728 
2729  case NTV2_STANDARD_720:
2730  fg = NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_FG_1280x740 : NTV2_FG_1280x720;
2731  if (NTV2_IS_VANCMODE_TALLER(inVancMode))
2732  CVIDWARN("'taller' mode requested for 720p -- using 'tall' geometry instead");
2733  break;
2734 
2735  case NTV2_STANDARD_525:
2736  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_720x514 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_720x508 : NTV2_FG_720x486);
2737  break;
2738 
2739  case NTV2_STANDARD_625:
2740  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_720x612 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_720x598 : NTV2_FG_720x576);
2741  break;
2742 
2743  case NTV2_STANDARD_2K:
2744  fg = NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_FG_2048x1588 : NTV2_FG_2048x1556;
2745  if (NTV2_IS_VANCMODE_TALLER(inVancMode))
2746  CVIDWARN("'taller' mode requested for 2K standard '" << ::NTV2StandardToString(st) << "' -- using 'tall' instead");
2747  break;
2748 
2749  case NTV2_STANDARD_2Kx1080p:
2750  case NTV2_STANDARD_2Kx1080i:
2751  fg = NTV2_IS_VANCMODE_TALLER(inVancMode) ? NTV2_FG_2048x1114 : (NTV2_IS_VANCMODE_TALL(inVancMode) ? NTV2_FG_2048x1112 : NTV2_FG_2048x1080);
2752  break;
2753 
2754  case NTV2_STANDARD_3840x2160p:
2755  case NTV2_STANDARD_4096x2160p:
2756  case NTV2_STANDARD_3840HFR:
2757  case NTV2_STANDARD_4096HFR:
2758  case NTV2_STANDARD_7680:
2759  case NTV2_STANDARD_8192:
2760  case NTV2_STANDARD_3840i:
2761  case NTV2_STANDARD_4096i:
2762  if (NTV2_IS_VANCMODE_ON(inVancMode))
2763  CVIDWARN("'tall' or 'taller' mode requested for '" << ::NTV2StandardToString(st) << "' -- using non-VANC geometry instead");
2764  break;
2765  #if defined(_DEBUG)
2766  case NTV2_STANDARD_INVALID: return false;
2767  #else
2768  default: return false;
2769  #endif // _DEBUG
2770  }
2771  SetFrameGeometry (fg, false/*ajaRetail*/, ch);
2772  CVIDINFO("'" << GetDisplayName() << "' Ch" << DEC(ch+1) << ": set to " << ::NTV2VANCModeToString(inVancMode) << " for " << ::NTV2StandardToString(st) << " and " << ::NTV2FrameGeometryToString(fg));
2773 
2774  // Only muck with limiting if not the xena2k board. Xena2k only turns off limiting in VANC area. Active video uses vidproccontrol setting...
2775  if (!::NTV2DeviceNeedsRoutingSetup(GetDeviceID()))
2776  SetVideoLimiting (NTV2_IS_VANCMODE_ON(inVancMode) ? NTV2_VIDEOLIMITING_OFF : NTV2_VIDEOLIMITING_LEGALSDI);
2777 
2778  return true;
2779 }
2780 
2781 
2782 //SetEnableVANCData - extended params
2783 bool CNTV2Card::SetEnableVANCData (const bool inVANCenabled, const bool inTallerVANC, const NTV2Standard inStandard, const NTV2FrameGeometry inFrameGeometry, const NTV2Channel inChannel)
2784 { (void) inStandard; (void) inFrameGeometry;
2785  if (inTallerVANC && !inVANCenabled)
2786  return false; // conflicting VANC params
2787  return SetVANCMode (NTV2VANCModeFromBools (inVANCenabled, inTallerVANC), inChannel);
2788 }
2789 
2790 
2791 bool CNTV2Card::GetVANCMode (NTV2VANCMode & outVancMode, const NTV2Channel inChannel)
2792 {
2793  bool isTall (false);
2794  bool isTaller (false);
2795  const NTV2Channel channel (IsMultiFormatActive() ? inChannel : NTV2_CHANNEL1);
2796  NTV2Standard standard (NTV2_STANDARD_INVALID);
2797  NTV2FrameGeometry frameGeometry (NTV2_FG_INVALID);
2798 
2799  if (IsMultiRasterWidgetChannel(channel))
2800  {outVancMode = NTV2_VANCMODE_OFF; return true;}
2801 
2802  outVancMode = NTV2_VANCMODE_INVALID;
2803  if (IS_CHANNEL_INVALID (channel))
2804  return false;
2805 
2806  GetStandard (standard, channel);
2807  GetFrameGeometry (frameGeometry, channel);
2808 
2809  switch (standard)
2810  {
2811  case NTV2_STANDARD_1080:
2812  case NTV2_STANDARD_1080p:
2813  case NTV2_STANDARD_2Kx1080p: // ** MrBill ** IS THIS CORRECT?
2814  case NTV2_STANDARD_2Kx1080i: // ** MrBill ** IS THIS CORRECT?
2815  if ( frameGeometry == NTV2_FG_1920x1112 || frameGeometry == NTV2_FG_2048x1112 ||
2816  frameGeometry == NTV2_FG_1920x1114 || frameGeometry == NTV2_FG_2048x1114)
2817  isTall = true;
2818  if ( frameGeometry == NTV2_FG_1920x1114 || frameGeometry == NTV2_FG_2048x1114)
2819  isTaller = true;
2820  break;
2821  case NTV2_STANDARD_720:
2822  if ( frameGeometry == NTV2_FG_1280x740)
2823  isTall = true;
2824  break;
2825  case NTV2_STANDARD_525:
2826  if ( frameGeometry == NTV2_FG_720x508 ||
2827  frameGeometry == NTV2_FG_720x514)
2828  isTall = true;
2829  if ( frameGeometry == NTV2_FG_720x514 )
2830  isTaller = true;
2831  break;
2832  case NTV2_STANDARD_625:
2833  if ( frameGeometry == NTV2_FG_720x598 ||
2834  frameGeometry == NTV2_FG_720x612)
2835  isTall = true;
2836  if ( frameGeometry == NTV2_FG_720x612 )
2837  isTaller = true;
2838  break;
2839  case NTV2_STANDARD_2K:
2840  if ( frameGeometry == NTV2_FG_2048x1588)
2841  isTall = true;
2842  break;
2843  case NTV2_STANDARD_3840x2160p:
2844  case NTV2_STANDARD_4096x2160p:
2845  case NTV2_STANDARD_3840HFR:
2846  case NTV2_STANDARD_4096HFR:
2847  case NTV2_STANDARD_7680:
2848  case NTV2_STANDARD_8192:
2849  case NTV2_STANDARD_3840i:
2850  case NTV2_STANDARD_4096i:
2851  break;
2852  #if defined (_DEBUG)
2853  case NTV2_NUM_STANDARDS: return false;
2854  #else
2855  default: return false;
2856  #endif
2857  }
2858  outVancMode = NTV2VANCModeFromBools (isTall, isTaller);
2859  return true;
2860 }
2861 
2862 
2863 bool CNTV2Card::SetVANCShiftMode (NTV2Channel inChannel, NTV2VANCDataShiftMode inValue)
2864 {
2865  if (IsMultiRasterWidgetChannel(inChannel))
2866  return inValue == NTV2_VANCDATA_NORMAL;
2867  if (IS_CHANNEL_INVALID (inChannel))
2868  return false;
2869  CVIDINFO("'" << GetDisplayName() << "' Ch" << DEC(inChannel+1) << ": Vanc data shift " << (inValue ? "enabled" : "disabled"));
2870  return WriteRegister (gChannelToControlRegNum [inChannel], inValue, kRegMaskVidProcVANCShift, kRegShiftVidProcVANCShift);
2871 }
2872 
2873 
2874 bool CNTV2Card::SetVANCShiftMode (NTV2ChannelSet & inChannels, const NTV2VANCDataShiftMode inMode)
2875 {
2876  size_t errors(0);
2877  for (NTV2ChannelSetConstIter it(inChannels.begin()); it != inChannels.end(); ++it)
2878  if (!SetVANCShiftMode(*it, inMode))
2879  errors++;
2880  return !errors;
2881 }
2882 
2883 
2884 bool CNTV2Card::GetVANCShiftMode (NTV2Channel inChannel, NTV2VANCDataShiftMode & outValue)
2885 {
2886  if (IsMultiRasterWidgetChannel(inChannel))
2887  {outValue = NTV2_VANCDATA_NORMAL; return true;}
2888  if (IS_CHANNEL_INVALID (inChannel))
2889  return false;
2890  return CNTV2DriverInterface::ReadRegister (gChannelToControlRegNum[inChannel], outValue, kRegMaskVidProcVANCShift, kRegShiftVidProcVANCShift);
2891 }
2892 
2893 
2894 bool CNTV2Card::SetPulldownMode (NTV2Channel inChannel, bool inValue)
2895 {
2896  if (IS_CHANNEL_INVALID (inChannel))
2897  return false;
2898  return WriteRegister (inChannel == NTV2_CHANNEL2 ? kRegCh2ControlExtended : kRegCh1ControlExtended, inValue, kK2RegMaskPulldownMode, kK2RegShiftPulldownMode);
2899 }
2900 
2901 
2902 bool CNTV2Card::GetPulldownMode (NTV2Channel inChannel, bool & outValue)
2903 {
2904  ULWord value(0);
2905  if (IS_CHANNEL_INVALID (inChannel))
2906  return false;
2907  if (ReadRegister (inChannel == NTV2_CHANNEL2 ? kRegCh2ControlExtended : kRegCh1ControlExtended, value, kK2RegMaskPulldownMode, kK2RegShiftPulldownMode))
2908  {
2909  outValue = value ? true : false;
2910  return true;
2911  }
2912  return false;
2913 }
2914 
2915 
2916 bool CNTV2Card::SetMixerVancOutputFromForeground (const UWord inWhichMixer, const bool inFromForegroundSource)
2917 {
2918  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2919  return false;
2920  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": Vanc from " << (inFromForegroundSource ? "FG" : "BG"));
2921  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inFromForegroundSource ? 1 : 0, kRegMaskVidProcVancSource, kRegShiftVidProcVancSource);
2922 }
2923 
2924 
2925 bool CNTV2Card::GetMixerVancOutputFromForeground (const UWord inWhichMixer, bool & outIsFromForegroundSource)
2926 {
2927  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2928  return false;
2929 
2930  ULWord value (0);
2931  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kRegMaskVidProcVancSource, kRegShiftVidProcVancSource));
2932  if (result)
2933  outIsFromForegroundSource = value ? true : false;
2934  return result;
2935 }
2936 
2937 bool CNTV2Card::SetMixerFGInputControl (const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
2938 {
2939  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2940  return false;
2941  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": FG input ctrl=" << ::NTV2MixerInputControlToString(inInputControl));
2942  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inInputControl, kK2RegMaskXena2FgVidProcInputControl, kK2RegShiftXena2FgVidProcInputControl);
2943 }
2944 
2945 
2946 bool CNTV2Card::GetMixerFGInputControl (const UWord inWhichMixer, NTV2MixerKeyerInputControl & outInputControl)
2947 {
2948  outInputControl = NTV2MIXERINPUTCONTROL_INVALID;
2949  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2950  return false;
2951 
2952  ULWord value (0);
2953  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2FgVidProcInputControl, kK2RegShiftXena2FgVidProcInputControl));
2954  if (result)
2955  outInputControl = static_cast <NTV2MixerKeyerInputControl> (value);
2956  return result;
2957 }
2958 
2959 
2960 bool CNTV2Card::SetMixerBGInputControl (const UWord inWhichMixer, const NTV2MixerKeyerInputControl inInputControl)
2961 {
2962  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2963  return false;
2964  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": BG input ctrl=" << ::NTV2MixerInputControlToString(inInputControl));
2965  return WriteRegister (gIndexToVidProcControlRegNum [inWhichMixer], inInputControl, kK2RegMaskXena2BgVidProcInputControl, kK2RegShiftXena2BgVidProcInputControl);
2966 }
2967 
2968 
2969 bool CNTV2Card::GetMixerBGInputControl (const UWord inWhichMixer, NTV2MixerKeyerInputControl & outInputControl)
2970 {
2971  outInputControl = NTV2MIXERINPUTCONTROL_INVALID;
2972  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2973  return false;
2974 
2975  ULWord value (0);
2976  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2BgVidProcInputControl, kK2RegShiftXena2BgVidProcInputControl));
2977  if (result)
2978  outInputControl = static_cast <NTV2MixerKeyerInputControl> (value);
2979  return result;
2980 }
2981 
2982 
2983 bool CNTV2Card::SetMixerMode (const UWord inWhichMixer, const NTV2MixerKeyerMode inMode)
2984 {
2985  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2986  return false;
2987  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": mode=" << ::NTV2MixerKeyerModeToString(inMode));
2988  return WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inMode, kK2RegMaskXena2VidProcMode, kK2RegShiftXena2VidProcMode);
2989 }
2990 
2991 
2992 bool CNTV2Card::GetMixerMode (const UWord inWhichMixer, NTV2MixerKeyerMode & outMode)
2993 {
2994  outMode = NTV2MIXERMODE_INVALID;
2995 
2996  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
2997  return false;
2998 
2999  ULWord value (0);
3000  bool result (ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], value, kK2RegMaskXena2VidProcMode, kK2RegShiftXena2VidProcMode));
3001  if (result)
3002  outMode = static_cast <NTV2MixerKeyerMode> (value);
3003  return result;
3004 }
3005 
3006 
3007 bool CNTV2Card::SetMixerCoefficient (const UWord inWhichMixer, const ULWord inMixCoefficient)
3008 {
3009  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3010  return false;
3011  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": mixCoeff=" << xHEX0N(inMixCoefficient,8));
3012  return WriteRegister (gIndexToVidProcMixCoeffRegNum[inWhichMixer], inMixCoefficient);
3013 }
3014 
3015 
3016 bool CNTV2Card::GetMixerCoefficient (const UWord inWhichMixer, ULWord & outMixCoefficient)
3017 {
3018  outMixCoefficient = 0;
3019  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3020  return false;
3021  return ReadRegister (gIndexToVidProcMixCoeffRegNum[inWhichMixer], outMixCoefficient);
3022 }
3023 
3024 
3025 bool CNTV2Card::GetMixerSyncStatus (const UWord inWhichMixer, bool & outIsSyncOK)
3026 {
3027  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3028  return false;
3029 
3030  bool syncFail (false);
3031  if (!CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], syncFail, kRegMaskVidProcSyncFail, kRegShiftVidProcSyncFail))
3032  return false;
3033  outIsSyncOK = syncFail ? false : true;
3034  return true;
3035 }
3036 
3037 bool CNTV2Card::GetMixerFGMatteEnabled (const UWord inWhichMixer, bool & outIsEnabled)
3038 {
3039  outIsEnabled = false;
3040  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3041  return false;
3042  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsEnabled, kRegMaskVidProcFGMatteEnable, kRegShiftVidProcFGMatteEnable);
3043 }
3044 
3045 bool CNTV2Card::SetMixerFGMatteEnabled (const UWord inWhichMixer, const bool inIsEnabled)
3046 {
3047  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3048  return false;
3049  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inIsEnabled?1:0, kRegMaskVidProcFGMatteEnable, kRegShiftVidProcFGMatteEnable);
3050 }
3051 
3052 bool CNTV2Card::GetMixerBGMatteEnabled (const UWord inWhichMixer, bool & outIsEnabled)
3053 {
3054  outIsEnabled = false;
3055  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3056  return false;
3057  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsEnabled, kRegMaskVidProcBGMatteEnable, kRegShiftVidProcBGMatteEnable);
3058 }
3059 
3060 bool CNTV2Card::SetMixerBGMatteEnabled (const UWord inWhichMixer, const bool inIsEnabled)
3061 {
3062  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3063  return false;
3064  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inIsEnabled?1:0, kRegMaskVidProcBGMatteEnable, kRegShiftVidProcBGMatteEnable);
3065 }
3066 
3067 static const ULWord gMatteColorRegs[] = { kRegFlatMatteValue /*13*/, kRegFlatMatte2Value /*249*/, kRegFlatMatte3Value /*487*/, kRegFlatMatte4Value /*490*/, 0, 0, 0, 0};
3068 
3069 bool CNTV2Card::GetMixerMatteColor (const UWord inWhichMixer, YCbCr10BitPixel & outYCbCrValue)
3070 {
3071  ULWord packedValue (0);
3072  outYCbCrValue.cb = outYCbCrValue.y = outYCbCrValue.cr = 0;
3073  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3074  return false;
3075  if (!ReadRegister(gMatteColorRegs[inWhichMixer], packedValue))
3076  return false;
3077 
3078  outYCbCrValue.cb = packedValue & 0x03FF;
3079  outYCbCrValue.y = ((packedValue >> 10) & 0x03FF) + 0x0040;
3080  outYCbCrValue.cr = (packedValue >> 20) & 0x03FF;
3081  return true;
3082 }
3083 
3084 bool CNTV2Card::SetMixerMatteColor (const UWord inWhichMixer, const YCbCr10BitPixel inYCbCrValue)
3085 {
3086  YCbCr10BitPixel ycbcrPixel (inYCbCrValue);
3087  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3088  return false;
3089 
3090  if (ycbcrPixel.y < 0x40)
3091  ycbcrPixel.y = 0x0; // clip y
3092  else
3093  ycbcrPixel.y -= 0x40;
3094  ycbcrPixel.y &= 0x3FF;
3095  ycbcrPixel.cb &= 0x3FF;
3096  ycbcrPixel.cr &= 0x3FF;
3097 
3098  // Pack three 10-bit values into ULWord...
3099  const ULWord packedValue (ULWord(ycbcrPixel.cb) | (ULWord(ycbcrPixel.y) << 10) | (ULWord(ycbcrPixel.cr) << 20));
3100  CVIDINFO("'" << GetDisplayName() << "' Mixer" << DEC(inWhichMixer+1) << ": set to YCbCr=" << DEC(ycbcrPixel.y)
3101  << "|" << DEC(ycbcrPixel.cb) << "|" << DEC(ycbcrPixel.cr) << ":" << HEXN(ycbcrPixel.y,3) << "|"
3102  << HEXN(ycbcrPixel.cb,3) << "|" << HEXN(ycbcrPixel.cr,3) << ", write " << xHEX0N(packedValue,8)
3103  << " into reg " << DEC(gMatteColorRegs[inWhichMixer]));
3104 
3105  // Write it...
3106  return WriteRegister(gMatteColorRegs[inWhichMixer], packedValue);
3107 }
3108 
3109 bool CNTV2Card::MixerHasRGBModeSupport (const UWord inWhichMixer, bool & outIsSupported)
3110 {
3111  outIsSupported = false;
3112  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3113  return false;
3114  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outIsSupported, kRegMaskVidProcRGBModeSupported, kRegShiftVidProcRGBModeSupported);
3115 }
3116 
3117 bool CNTV2Card::SetMixerRGBRange (const UWord inWhichMixer, const NTV2MixerRGBRange inRGBRange)
3118 {
3119  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3120  return false;
3121  return !WriteRegister (gIndexToVidProcControlRegNum[inWhichMixer], inRGBRange, kRegMaskVidProcRGBRange, kRegShiftVidProcRGBRange);
3122 }
3123 
3124 bool CNTV2Card::GetMixerRGBRange (const UWord inWhichMixer, NTV2MixerRGBRange & outRGBRange)
3125 {
3126  if (ULWord(inWhichMixer) >= GetNumSupported(kDeviceGetNumMixers))
3127  return false;
3128  return !CNTV2DriverInterface::ReadRegister (gIndexToVidProcControlRegNum[inWhichMixer], outRGBRange, kRegMaskVidProcRGBRange, kRegShiftVidProcRGBRange);
3129 }
3130 
3131 
3133 // Mapping methods
3135 
3136 #if !defined(NTV2_DEPRECATE_16_0)
3137  // Method: GetBaseAddress
3138  // Input: NTV2Channel channel
3139  // Output: bool status and modifies ULWord **pBaseAddress
3140  bool CNTV2Card::GetBaseAddress (NTV2Channel channel, ULWord **pBaseAddress)
3141  {
3142  if (IS_CHANNEL_INVALID(channel))
3143  return false;
3144  ULWord ulFrame(0);
3145  if (!ReadRegister(gChannelToPCIAccessFrameRegNum[channel], ulFrame)) // GetPCIAccessFrame(channel, ulFrame);
3146  return false;
3147  if (ulFrame > GetNumFrameBuffers())
3148  ulFrame = 0;
3149 
3150  if (::NTV2DeviceIsDirectAddressable(GetDeviceID()))
3151  {
3152  if (!_pFrameBaseAddress)
3153  if (!MapFrameBuffers())
3154  return false;
3155  *pBaseAddress = _pFrameBaseAddress + ((ulFrame * _ulFrameBufferSize) / sizeof(ULWord));
3156  }
3157  else // must be an _MM board
3158  {
3159  if (!_pCh1FrameBaseAddress)
3160  if (!MapFrameBuffers())
3161  return false;
3162  *pBaseAddress = (channel == NTV2_CHANNEL1) ? _pCh1FrameBaseAddress : _pCh2FrameBaseAddress; // DEPRECATE!
3163  }
3164  return true;
3165  }
3166 
3167  // Method: GetBaseAddress
3168  // Input: None
3169  // Output: bool status and modifies ULWord *pBaseAddress
3170  bool CNTV2Card::GetBaseAddress (ULWord **pBaseAddress)
3171  {
3172  if (!_pFrameBaseAddress)
3173  if (!MapFrameBuffers())
3174  return false;
3175  *pBaseAddress = _pFrameBaseAddress;
3176  return true;
3177  }
3178 
3179  // Method: GetRegisterBaseAddress
3180  // Input: ULWord regNumber
3181  // Output: bool status and modifies ULWord **pBaseAddress
3182  bool CNTV2Card::GetRegisterBaseAddress (ULWord regNumber, ULWord **pBaseAddress)
3183  {
3184  if (!_pRegisterBaseAddress)
3185  if (!MapRegisters())
3186  return false;
3187  #ifdef MSWindows
3188  if ((regNumber*4) >= _pRegisterBaseAddressLength)
3189  return false;
3190  #endif // MSWindows
3191  *pBaseAddress = _pRegisterBaseAddress + regNumber;
3192  return true;
3193  }
3194 
3195  // Method: GetXena2FlashBaseAddress
3196  // Output: bool status and modifies ULWord **pXena2FlashAddress
3197  bool CNTV2Card::GetXena2FlashBaseAddress (ULWord **pXena2FlashAddress)
3198  {
3199  if (!_pXena2FlashBaseAddress)
3200  if (!MapXena2Flash())
3201  return false;
3202  *pXena2FlashAddress = _pXena2FlashBaseAddress;
3203  return true;
3204  }
3205 #endif // !defined(NTV2_DEPRECATE_16_0)
3206 
3207 bool CNTV2Card::SetDualLinkOutputEnable (const bool enable)
3208 {
3209  return WriteRegister (kRegGlobalControl, enable ? 1 : 0, kRegMaskDualLinkOutEnable, kRegShiftDualLinKOutput);
3210 }
3211 
3212 bool CNTV2Card::GetDualLinkOutputEnable (bool & outIsEnabled)
3213 {
3214  outIsEnabled = false;
3215  return CNTV2DriverInterface::ReadRegister (kRegGlobalControl, outIsEnabled, kRegMaskDualLinkOutEnable, kRegShiftDualLinKOutput);
3216 }
3217 
3218 
3219 bool CNTV2Card::SetDualLinkInputEnable (const bool enable)
3220 {
3221  return WriteRegister (kRegGlobalControl, enable ? 1 : 0, kRegMaskDualLinkInEnable, kRegShiftDualLinkInput);
3222 }
3223 
3224 
3225 bool CNTV2Card::GetDualLinkInputEnable (bool & outIsEnabled)
3226 {
3227  outIsEnabled = false;
3228  return CNTV2DriverInterface::ReadRegister (kRegGlobalControl, outIsEnabled, kRegMaskDualLinkInEnable, kRegShiftDualLinkInput);
3229 }
3230 
3231 
3233 
3234 bool CNTV2Card::SetDitherFor8BitInputs (const NTV2Channel inChannel, const ULWord inDither)
3235 {
3236  if (IS_CHANNEL_INVALID(inChannel))
3237  return false;
3238  return WriteRegister (gChannelToControlRegNum[inChannel], inDither, kRegMaskDitherOn8BitInput, kRegShiftDitherOn8BitInput);
3239 }
3240 
3241 bool CNTV2Card::GetDitherFor8BitInputs (const NTV2Channel inChannel, ULWord & outDither)
3242 {
3243  if (IS_CHANNEL_INVALID(inChannel))
3244  return false;
3245  return ReadRegister(gChannelToControlRegNum[inChannel], outDither, kRegMaskDitherOn8BitInput, kRegShiftDitherOn8BitInput);
3246 }
3247 
3249 
3250 bool CNTV2Card::SetForce64(ULWord force64) {return WriteRegister (kRegDMAControl, force64, kRegMaskForce64, kRegShiftForce64);}
3251 bool CNTV2Card::GetForce64(ULWord* force64) {return force64 ? ReadRegister (kRegDMAControl, *force64, kRegMaskForce64, kRegShiftForce64) : false;}
3252 bool CNTV2Card::Get64BitAutodetect(ULWord* autodetect64) {return autodetect64 ? ReadRegister (kRegDMAControl, *autodetect64, kRegMaskAutodetect64, kRegShiftAutodetect64) : false;}
3253 
3255 // Kona2/Xena2/ related methods
3256 
3257 // kK2RegAnalogOutControl
3258 bool CNTV2Card::SetVideoDACMode (NTV2VideoDACMode value) {return WriteRegister (kRegAnalogOutControl, value, kK2RegMaskVideoDACMode, kK2RegShiftVideoDACMode);}
3259 bool CNTV2Card::GetVideoDACMode (NTV2VideoDACMode & outValue) {return CNTV2DriverInterface::ReadRegister (kRegAnalogOutControl, outValue, kK2RegMaskVideoDACMode, kK2RegShiftVideoDACMode);}
3260 bool CNTV2Card::SetAnalogOutHTiming (ULWord value) {return WriteRegister (kRegAnalogOutControl, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3261 bool CNTV2Card::GetAnalogOutHTiming (ULWord & outValue) {return ReadRegister (kRegAnalogOutControl, outValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3262 
3263 bool CNTV2Card::SetSDIOutputStandard (const UWord inOutputSpigot, const NTV2Standard inValue)
3264 {
3265  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3266  return false;
3267 
3268  NTV2Standard standard(inValue);
3269  bool is2Kx1080(false);
3270  switch(inValue)
3271  {
3272  case NTV2_STANDARD_2Kx1080p:
3273  standard = NTV2_STANDARD_1080p;
3274  is2Kx1080 = true;
3275  break;
3276  case NTV2_STANDARD_2Kx1080i:
3277  standard = NTV2_STANDARD_1080;
3278  is2Kx1080 = true;
3279  break;
3280  case NTV2_STANDARD_3840x2160p:
3281  standard = NTV2_STANDARD_1080p;
3282  is2Kx1080 = false;
3283  break;
3284  case NTV2_STANDARD_3840HFR:
3285  standard = NTV2_STANDARD_1080p;
3286  is2Kx1080 = false;
3287  break;
3288  case NTV2_STANDARD_3840i:
3289  standard = NTV2_STANDARD_1080;
3290  is2Kx1080 = false;
3291  break;
3292  case NTV2_STANDARD_4096x2160p:
3293  standard = NTV2_STANDARD_1080p;
3294  is2Kx1080 = true;
3295  break;
3296  case NTV2_STANDARD_4096HFR:
3297  standard = NTV2_STANDARD_1080p;
3298  is2Kx1080 = true;
3299  break;
3300  case NTV2_STANDARD_4096i:
3301  standard = NTV2_STANDARD_1080;
3302  is2Kx1080 = true;
3303  break;
3304  default:
3305  break;
3306  }
3307 
3308  return WriteRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], standard, kK2RegMaskSDIOutStandard, kK2RegShiftSDIOutStandard)
3309  && SetSDIOut2Kx1080Enable(NTV2Channel(inOutputSpigot), is2Kx1080);
3310 }
3311 
3312 bool CNTV2Card::SetSDIOutputStandard (const NTV2ChannelSet & inSDIOutputs, const NTV2Standard inValue)
3313 {
3314  size_t errors(0);
3315  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
3316  if (!SetSDIOutputStandard(*it, inValue))
3317  errors++;
3318  return !errors;
3319 }
3320 
3321 bool CNTV2Card::GetSDIOutputStandard (const UWord inOutputSpigot, NTV2Standard & outValue)
3322 {
3323  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3324  return false;
3325  bool is2kx1080(false);
3326  bool is6G(false);
3327  bool is12G(false);
3328  NTV2Standard newStd(NTV2_STANDARD_INVALID);
3329  const bool result (CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], newStd, kK2RegMaskSDIOutStandard, kK2RegShiftSDIOutStandard)
3330  && GetSDIOut2Kx1080Enable(NTV2Channel(inOutputSpigot), is2kx1080)
3331  && GetSDIOut6GEnable(NTV2Channel(inOutputSpigot), is6G)
3332  && GetSDIOut12GEnable(NTV2Channel(inOutputSpigot), is12G));
3333  outValue = newStd;
3334  switch (newStd)
3335  {
3336  case NTV2_STANDARD_1080:
3337  if (is2kx1080)
3338  outValue = NTV2_STANDARD_2Kx1080i;
3339  if (is6G || is12G)
3340  outValue = is2kx1080 ? NTV2_STANDARD_4096i : NTV2_STANDARD_3840i;
3341  break;
3342  case NTV2_STANDARD_1080p:
3343  if (is2kx1080)
3344  outValue = NTV2_STANDARD_2Kx1080p;
3345  if (is6G || is12G)
3346  outValue = is2kx1080 ? NTV2_STANDARD_4096x2160p : NTV2_STANDARD_3840x2160p;
3347  break;
3348  default:
3349  break;
3350  }
3351  return result;
3352 }
3353 
3354 bool CNTV2Card::WriteOutputTimingControl (const ULWord inValue, const UWord inOutputSpigot)
3355 {
3356  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
3357  return false;
3358  if (IsMultiFormatActive())
3359  return WriteRegister (gChannelToOutputTimingCtrlRegNum[inOutputSpigot], inValue);
3360  else if (IsSupported(kDeviceCanDoMultiFormat))
3361  {
3362  // Write all of the timing registers for UniFormat mode...
3363  switch (GetNumSupported(kDeviceGetNumVideoChannels))
3364  {
3365  case 8:
3366  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL8], inValue);
3367  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL7], inValue);
3368  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL6], inValue);
3369  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL5], inValue);
3370  AJA_FALL_THRU;
3371  case 4:
3372  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL4], inValue);
3373  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL3], inValue);
3374  AJA_FALL_THRU;
3375  case 2:
3376  WriteRegister (gChannelToOutputTimingCtrlRegNum[NTV2_CHANNEL2], inValue);
3377  AJA_FALL_THRU;
3378  default:
3379  return WriteRegister (gChannelToOutputTimingCtrlRegNum [NTV2_CHANNEL1], inValue);
3380  }
3381  }
3382  else
3383  return WriteRegister (gChannelToOutputTimingCtrlRegNum [NTV2_CHANNEL1], inValue);
3384 }
3385 
3386 
3387 bool CNTV2Card::ReadOutputTimingControl (ULWord & outValue, const UWord inOutputSpigot)
3388 {
3389  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
3390  return false;
3391  return ReadRegister (gChannelToOutputTimingCtrlRegNum[IsMultiFormatActive() ? inOutputSpigot : UWord(NTV2_CHANNEL1)], outValue);
3392 }
3393 
3394 // SDI1 HTiming
3395 bool CNTV2Card::SetSDI1OutHTiming (ULWord value) {return WriteRegister (kRegSDIOut1Control, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3396 bool CNTV2Card::GetSDI1OutHTiming(ULWord* pValue) {return pValue ? ReadRegister(kRegSDIOut1Control, *pValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming) : false;}
3397 
3398 // SDI2 HTiming
3399 bool CNTV2Card::SetSDI2OutHTiming (ULWord value) {return WriteRegister (kRegSDIOut2Control, value, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming);}
3400 bool CNTV2Card::GetSDI2OutHTiming(ULWord* pValue) {return pValue ? ReadRegister(kRegSDIOut2Control, *pValue, kK2RegMaskOutHTiming, kK2RegShiftOutHTiming) : false;}
3401 
3402 bool CNTV2Card::SetSecondaryVideoFormat(NTV2VideoFormat format)
3403 {
3404  return WriteRegister(kVRegSecondaryFormatSelect, format);
3405 }
3406 
3407 bool CNTV2Card::GetSecondaryVideoFormat(NTV2VideoFormat & outFormat)
3408 {
3409  return CNTV2DriverInterface::ReadRegister (kVRegSecondaryFormatSelect, outFormat);
3410 }
3411 
3412 
3413 #if !defined(R2_DEPRECATE)
3414 
3415 bool CNTV2Card::SetInputVideoSelect (NTV2InputVideoSelect input)
3416 {
3417  return WriteRegister(kVRegInputSelect, input);
3418 }
3419 
3420 bool CNTV2Card::GetInputVideoSelect(NTV2InputVideoSelect & outInputSelect)
3421 {
3422  return CNTV2DriverInterface::ReadRegister(kVRegInputSelect, outInputSelect);
3423 }
3424 
3425 #endif // R2_DEPRECATE
3426 
3427 
3428 NTV2VideoFormat CNTV2Card::GetInputVideoFormat (NTV2InputSource inSource, const bool inIsProgressivePicture)
3429 {
3430  switch (inSource)
3431  {
3432  case NTV2_INPUTSOURCE_SDI1: return GetSDIInputVideoFormat (NTV2_CHANNEL1, inIsProgressivePicture);
3433  case NTV2_INPUTSOURCE_SDI2: return GetSDIInputVideoFormat (NTV2_CHANNEL2, inIsProgressivePicture);
3434  case NTV2_INPUTSOURCE_SDI3: return GetSDIInputVideoFormat (NTV2_CHANNEL3, inIsProgressivePicture);
3435  case NTV2_INPUTSOURCE_SDI4: return GetSDIInputVideoFormat (NTV2_CHANNEL4, inIsProgressivePicture);
3436  case NTV2_INPUTSOURCE_SDI5: return GetSDIInputVideoFormat (NTV2_CHANNEL5, inIsProgressivePicture);
3437  case NTV2_INPUTSOURCE_SDI6: return GetSDIInputVideoFormat (NTV2_CHANNEL6, inIsProgressivePicture);
3438  case NTV2_INPUTSOURCE_SDI7: return GetSDIInputVideoFormat (NTV2_CHANNEL7, inIsProgressivePicture);
3439  case NTV2_INPUTSOURCE_SDI8: return GetSDIInputVideoFormat (NTV2_CHANNEL8, inIsProgressivePicture);
3440  case NTV2_INPUTSOURCE_HDMI1: return GetHDMIInputVideoFormat (NTV2_CHANNEL1);
3441  case NTV2_INPUTSOURCE_HDMI2: return GetHDMIInputVideoFormat (NTV2_CHANNEL2);
3442  case NTV2_INPUTSOURCE_HDMI3: return GetHDMIInputVideoFormat (NTV2_CHANNEL3);
3443  case NTV2_INPUTSOURCE_HDMI4: return GetHDMIInputVideoFormat (NTV2_CHANNEL4);
3444  case NTV2_INPUTSOURCE_ANALOG1: return GetAnalogInputVideoFormat ();
3445  default: return NTV2_FORMAT_UNKNOWN;
3446  }
3447 }
3448 
3449 NTV2VideoFormat CNTV2Card::GetSDIInputVideoFormat (NTV2Channel inChannel, bool inIsProgressivePicture)
3450 {
3451  ULWord vpidDS1(0), vpidDS2(0);
3452  CNTV2VPID inputVPID;
3453  if (IS_CHANNEL_INVALID(inChannel))
3454  return NTV2_FORMAT_UNKNOWN;
3455 
3456  bool isValidVPID (GetVPIDValidA(inChannel));
3457  if (isValidVPID)
3458  {
3459  ReadSDIInVPID(inChannel, vpidDS1, vpidDS2);
3460  inputVPID.SetVPID(vpidDS1);
3461  isValidVPID = inputVPID.IsValid();
3462  }
3463 
3464  NTV2FrameRate inputRate(GetSDIInputRate(inChannel));
3465  NTV2FrameGeometry inputGeometry(GetSDIInputGeometry(inChannel));
3466  bool isProgressiveTrans (isValidVPID ? inputVPID.GetProgressiveTransport() : GetSDIInputIsProgressive(inChannel));
3467  bool isProgressivePic (isValidVPID ? inputVPID.GetProgressivePicture() : inIsProgressivePicture);
3468  bool isInput3G (false);
3469 
3470  if(inputRate == NTV2_FRAMERATE_INVALID)
3471  return NTV2_FORMAT_UNKNOWN;
3472 
3473  const ULWordSet wgtIDs (GetSupportedItems(kNTV2EnumsID_WidgetID));
3474  const bool canDo292In (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn, inChannel)) != wgtIDs.end());
3475  const bool canDo3GIn (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn3G, inChannel)) != wgtIDs.end());
3476  const bool canDo12GIn (wgtIDs.find(CNTV2SignalRouter::WidgetIDFromTypeAndChannel(NTV2WidgetType_SDIIn12G, inChannel)) != wgtIDs.end());
3477 
3478  if (canDo3GIn || canDo12GIn)
3479  {
3480  GetSDIInput3GPresent(isInput3G, inChannel);
3481  NTV2VideoFormat format = isValidVPID ? inputVPID.GetVideoFormat() : GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3482  if (isValidVPID && format == NTV2_FORMAT_UNKNOWN)
3483  {
3484  // Something might be incorrect in VPID
3485  isProgressiveTrans = GetSDIInputIsProgressive(inChannel);
3486  isProgressivePic = inIsProgressivePicture;
3487  format = GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3488  }
3489  if (canDo12GIn && format != NTV2_FORMAT_UNKNOWN && !isValidVPID)
3490  {
3491  bool is6G(false), is12G(false);
3492  GetSDIInput6GPresent(is6G, inChannel);
3493  GetSDIInput12GPresent(is12G, inChannel);
3494  if (is6G || is12G)
3495  {
3496  format = GetQuadSizedVideoFormat(format, !IsSupported(kDeviceCanDo12gRouting) ? true : false);
3497  }
3498  if (inputVPID.IsStandardMultiLink4320())
3499  {
3500  format = GetQuadSizedVideoFormat(format, true);
3501  }
3502  }
3503  return format;
3504  }
3505 
3506  if (canDo292In)
3507  {
3508  if (_boardID == DEVICE_ID_KONALHI || _boardID == DEVICE_ID_KONALHIDVI)
3509  {
3510  GetSDIInput3GPresent(isInput3G, NTV2_CHANNEL1);
3511  }
3512  return GetNTV2VideoFormat(inputRate, inputGeometry, isProgressiveTrans, isInput3G, isProgressivePic);
3513  }
3514 
3515  return NTV2_FORMAT_UNKNOWN;
3516 }
3517 
3518 
3519 NTV2VideoFormat CNTV2Card::GetHDMIInputVideoFormat(NTV2Channel inChannel)
3520 {
3521  NTV2VideoFormat format = NTV2_FORMAT_UNKNOWN;
3522  ULWord status;
3523  if (GetHDMIInputStatus(status, inChannel))
3524  {
3525  if ( (status & kRegMaskInputStatusLock) != 0 )
3526  {
3527  ULWord hdmiVersion = GetNumSupported(kDeviceGetHDMIVersion);
3528  if(hdmiVersion == 1)
3529  {
3530  ULWord standard = ((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd);
3531  if(standard == 0x5) // NTV2_STANDARD_2K (2048x1556psf) in HDMI is really SXGA!!
3532  {
3533  // We return 1080p60 for SXGA format
3534  return NTV2_FORMAT_1080p_6000_A;
3535  }
3536  else
3537  {
3538  format = GetNTV2VideoFormat (NTV2FrameRate((status & kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS),
3539  NTV2Standard((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd),
3540  false, // 3G
3541  0, // input geometry
3542  false); // progressive picture
3543  }
3544  }
3545  else if(hdmiVersion > 1)
3546  {
3547  bool squareDivision = hdmiVersion == 5 ? false : true;
3548  NTV2FrameRate hdmiRate = NTV2FrameRate((status &kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS);
3549  NTV2Standard hdmiStandard = NTV2Standard((status & kRegMaskHDMIInV2VideoStd) >> kRegShiftHDMIInV2VideoStd);
3550  UByte inputGeometry = 0;
3551  if (hdmiStandard == NTV2_STANDARD_2Kx1080i || hdmiStandard == NTV2_STANDARD_2Kx1080p)
3552  inputGeometry = 8;
3553  format = GetNTV2VideoFormat (hdmiRate, hdmiStandard, false, inputGeometry, false, squareDivision);
3554  }
3555  }
3556  }
3557  return format;
3558 }
3559 
3560 NTV2VideoFormat CNTV2Card::GetAnalogInputVideoFormat()
3561 {
3562  NTV2VideoFormat format = NTV2_FORMAT_UNKNOWN;
3563  ULWord status;
3564  if (ReadRegister(kRegAnalogInputStatus, status))
3565  {
3566  if ( (status & kRegMaskInputStatusLock) != 0 )
3567  format = GetNTV2VideoFormat ( NTV2FrameRate((status & kRegMaskInputStatusFPS) >> kRegShiftInputStatusFPS),
3568  NTV2Standard ((status & kRegMaskInputStatusStd) >> kRegShiftInputStatusStd),
3569  false, // 3G
3570  0, // input geometry
3571  false); // progressive picture
3572  }
3573  return format;
3574 }
3575 
3576 NTV2VideoFormat CNTV2Card::GetAnalogCompositeInputVideoFormat (void)
3577 {
3578  NTV2VideoFormat format(NTV2_FORMAT_UNKNOWN);
3579  ULWord analogDetect(0);
3580  // Use a single (atomic) read... so we don't return a bogus value if the register is changing while we're in here!
3581  if (ReadRegister(kRegAnalogInputStatus, analogDetect))
3582  {
3583  const ULWord locked ((analogDetect & kRegMaskAnalogCompositeLocked) >> kRegShiftAnalogCompositeLocked);
3584  if (locked)
3585  {
3586  const ULWord Pal ((analogDetect & kRegMaskAnalogCompositeFormat625) >> kRegShiftAnalogCompositeFormat625);
3587  // Validate NTSC/PAL reading with Frame Rate Family
3588  const ULWord integerRate ((analogDetect & kRegMaskAnalogInputIntegerRate) >> kRegShiftAnalogInputIntegerRate);
3589  if (Pal)
3590  {
3591  if (integerRate)
3592  format = NTV2_FORMAT_625_5000;
3593  else
3594  format = NTV2_FORMAT_UNKNOWN; // illegal combination - 625/59.94
3595  }
3596  else
3597  {
3598  if (integerRate)
3599  format = NTV2_FORMAT_UNKNOWN; // illegal combination - 525/60
3600  else
3601  format = NTV2_FORMAT_525_5994;
3602  }
3603  }
3604  }
3605  return format;
3606 }
3607 
3608 
3609 NTV2VideoFormat CNTV2Card::GetReferenceVideoFormat (void)
3610 {
3611  ULWord status(0);
3612  if (!ReadRegister(kRegInputStatus, status))
3613  return NTV2_FORMAT_UNKNOWN;
3614  return GetNTV2VideoFormat (NTV2FrameRate((status >> 16) & 0xF), // frame rate
3615  ((status >> 20) & 0x7), // input scan geometry
3616  (status & BIT_23) ? true : false, // progressive transport
3617  false, // 3G
3618  false); // progressive picture
3619 }
3620 
3621 NTV2FrameRate CNTV2Card::GetSDIInputRate (const NTV2Channel channel)
3622 {
3623  if (IS_CHANNEL_INVALID (channel))
3624  return NTV2_FRAMERATE_INVALID;
3625 
3626  ULWord rateLow (0), rateHigh (0);
3627  NTV2FrameRate currentRate (NTV2_FRAMERATE_INVALID);
3628  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], rateLow,
3629  gChannelToSDIInputRateMask[channel], gChannelToSDIInputRateShift[channel]))
3630  return NTV2_FRAMERATE_INVALID;
3631  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], rateHigh,
3632  gChannelToSDIInputRateHighMask[channel], gChannelToSDIInputRateHighShift[channel]))
3633  return NTV2_FRAMERATE_INVALID;
3634  currentRate = NTV2FrameRate(((rateHigh << 3) & BIT_3) | rateLow);
3635  return NTV2_IS_VALID_NTV2FrameRate(currentRate) ? currentRate : NTV2_FRAMERATE_INVALID;
3636 } // GetSDIInputRate
3637 
3638 NTV2FrameGeometry CNTV2Card::GetSDIInputGeometry (const NTV2Channel channel)
3639 {
3640  if (IS_CHANNEL_INVALID (channel))
3641  return NTV2_FG_INVALID;
3642 
3643  ULWord geometryLow (0), geometryHigh (0);
3644  NTV2FrameGeometry currentGeometry (NTV2_FG_INVALID);
3645  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], geometryLow,
3646  gChannelToSDIInputGeometryMask[channel], gChannelToSDIInputGeometryShift[channel]))
3647  return NTV2_FG_INVALID;
3648  if (!ReadRegister(gChannelToSDIInputStatusRegNum[channel], geometryHigh,
3649  gChannelToSDIInputGeometryHighMask[channel], gChannelToSDIInputGeometryHighShift[channel]))
3650  return NTV2_FG_INVALID;
3651  currentGeometry = NTV2FrameGeometry(((geometryHigh << 3) & BIT_3) | geometryLow);
3652  return NTV2_IS_VALID_NTV2FrameGeometry(currentGeometry) ? currentGeometry : NTV2_FG_INVALID;
3653 } // GetSDIInputGeometry
3654 
3655 bool CNTV2Card::GetSDIInputIsProgressive (const NTV2Channel channel)
3656 {
3657  if (IS_CHANNEL_INVALID (channel))
3658  return false;
3659 
3660  ULWord isProgressive = 0;
3661  ReadRegister(gChannelToSDIInputStatusRegNum[channel], isProgressive, gChannelToSDIInputProgressiveMask[channel], gChannelToSDIInputProgressiveShift[channel]);
3662  return isProgressive ? true : false;
3663 } // GetSDIInputIsProgressive
3664 
3665 bool CNTV2Card::GetSDIInput3GPresent (bool & outValue, const NTV2Channel channel)
3666 {
3667  if (IS_CHANNEL_INVALID (channel))
3668  return false;
3669 
3670  ULWord value (0);
3671  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn3GModeMask[channel], gChannelToSDIIn3GModeShift[channel]));
3672  outValue = static_cast <bool> (value);
3673  return result;
3674 
3675 } // GetSDIInput3GPresent
3676 
3677 bool CNTV2Card::GetSDIInput3GbPresent (bool & outValue, const NTV2Channel channel)
3678 {
3679  if (IS_CHANNEL_INVALID (channel))
3680  return false;
3681 
3682  ULWord value (0);
3683  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn3GbModeMask[channel], gChannelToSDIIn3GbModeShift[channel]));
3684  outValue = static_cast <bool> (value);
3685  return result;
3686 
3687 } // GetSDIInput3GPresent
3688 
3689 bool CNTV2Card::GetSDIInput6GPresent (bool & outValue, const NTV2Channel channel)
3690 {
3691  if (IS_CHANNEL_INVALID (channel))
3692  return false;
3693 
3694  ULWord value (0);
3695  bool result (ReadRegister (gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn6GModeMask[channel], gChannelToSDIIn6GModeShift[channel]));
3696  outValue = static_cast <bool> (value);
3697  return result;
3698 
3699 } // GetSDIInput3GPresent
3700 
3701 bool CNTV2Card::GetSDIInput12GPresent (bool & outValue, const NTV2Channel channel)
3702 {
3703  if (IS_CHANNEL_INVALID (channel))
3704  return false;
3705 
3706  ULWord value (0);
3707  bool result (ReadRegister(gChannelToSDIInput3GStatusRegNum[channel], value, gChannelToSDIIn12GModeMask[channel], gChannelToSDIIn12GModeShift[channel]));
3708  outValue = static_cast <bool> (value);
3709  return result;
3710 
3711 } // GetSDIInput3GPresent
3712 
3713 
3714 bool CNTV2Card::SetLTCInputEnable (bool inEnable)
3715 {
3716  if (GetDeviceID() == DEVICE_ID_CORVID24)
3717  inEnable = !inEnable; // Oops, Corvid24's LTCOnRefInSelect bit sense was flipped
3718  return WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kFS1RefMaskLTCOnRefInSelect, kFS1RefShiftLTCOnRefInSelect)
3719  && WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kRegMaskLTCOnRefInSelect, kRegShiftLTCOnRefInSelect);
3720 }
3721 
3722 bool CNTV2Card::GetLTCInputEnable (bool & outIsEnabled)
3723 {
3724  if (!CNTV2DriverInterface::ReadRegister (kRegFS1ReferenceSelect, outIsEnabled, kFS1RefMaskLTCOnRefInSelect, kFS1RefShiftLTCOnRefInSelect))
3725  return false;
3726  if (GetDeviceID() == DEVICE_ID_CORVID24)
3727  outIsEnabled = !outIsEnabled; // Oops, Corvid24's LTCOnRefInSelect bit sense was flipped
3728  return true;
3729 }
3730 
3731 bool CNTV2Card::GetLTCInputPresent (bool & outIsPresent, const UWord inLTCInputNdx)
3732 {
3733  if (ULWord(inLTCInputNdx) >= GetNumSupported(kDeviceGetNumLTCInputs))
3734  return false; // No such LTC input
3735  if (inLTCInputNdx) // LTCIn2
3736  return CNTV2DriverInterface::ReadRegister (kRegLTCStatusControl, outIsPresent, kRegMaskLTC2InPresent, kRegShiftLTC2InPresent);
3737  else // LTCIn1
3738  {
3739  CNTV2DriverInterface::ReadRegister (kRegStatus, outIsPresent, kRegMaskLTCInPresent, kRegShiftLTCInPresent);
3740  if(outIsPresent)
3741  return true;
3742  return CNTV2DriverInterface::ReadRegister (kRegLTCStatusControl, outIsPresent, kRegMaskLTC1InPresent, kRegShiftLTC1InPresent);
3743  }
3744 }
3745 
3746 #if !defined(NTV2_DEPRECATE_16_3)
3747  bool CNTV2Card::SetLTCEmbeddedOutEnable (const bool inEnable)
3748  {
3749  return WriteRegister (kRegFS1ReferenceSelect, ULWord(inEnable), kFS1RefMaskLTCEmbeddedOutEnable, kFS1RefShiftLTCEmbeddedOutEnable);
3750  }
3751 
3752  bool CNTV2Card::GetLTCEmbeddedOutEnable (bool & outEnabled)
3753  {
3754  return CNTV2DriverInterface::ReadRegister (kRegFS1ReferenceSelect, outEnabled, kFS1RefMaskLTCEmbeddedOutEnable, kFS1RefShiftLTCEmbeddedOutEnable);
3755  }
3756 #endif // !defined(NTV2_DEPRECATE_16_3)
3757 
3758 bool CNTV2Card::ReadAnalogLTCInput (const UWord inLTCInput, RP188_STRUCT & outRP188Data)
3759 {
3760  NTV2_RP188 result;
3761  if (!ReadAnalogLTCInput(inLTCInput, result))
3762  return false;
3763  outRP188Data = result;
3764  return true;
3765 }
3766 
3767 
3768 bool CNTV2Card::ReadAnalogLTCInput (const UWord inLTCInput, NTV2_RP188 & outRP188Data)
3769 {
3770  outRP188Data.Set();
3771  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3772  return false;
3773 
3774  const ULWord regLo (inLTCInput ? kRegLTC2AnalogBits0_31 : kRegLTCAnalogBits0_31 );
3775  const ULWord regHi (inLTCInput ? kRegLTC2AnalogBits32_63 : kRegLTCAnalogBits32_63);
3776  outRP188Data.fDBB = 0;
3777  return ReadRegister(regLo, outRP188Data.fLo) && ReadRegister(regHi, outRP188Data.fHi);
3778 }
3779 
3780 
3781 bool CNTV2Card::GetAnalogLTCInClockChannel (const UWord inLTCInput, NTV2Channel & outChannel)
3782 {
3783  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3784  return false;
3785 
3786  ULWord value(0);
3787  if (!ReadRegister (kRegLTCStatusControl, value, 0x7, inLTCInput ? 9 : 1)) // Bits 1|2|3 for LTCIn1, bits 9|10|11 for LTCIn2
3788  return false;
3789  outChannel = NTV2Channel(value + 1);
3790  return true;
3791 }
3792 
3793 
3794 bool CNTV2Card::SetAnalogLTCInClockChannel (const UWord inLTCInput, const NTV2Channel inChannel)
3795 {
3796  if (ULWord(inLTCInput) >= GetNumSupported(kDeviceGetNumLTCInputs))
3797  return false;
3798  if (IS_CHANNEL_INVALID(inChannel))
3799  return false;
3800  return WriteRegister (kRegLTCStatusControl, inChannel - 1, 0x7, inLTCInput ? 9 : 1); // Bits 1|2|3 for LTCIn1, bits 9|10|11 for LTCIn2
3801 }
3802 
3803 
3804 bool CNTV2Card::WriteAnalogLTCOutput (const UWord inLTCOutput, const RP188_STRUCT & inRP188Data)
3805 {
3806  const NTV2_RP188 rp188data(inRP188Data);
3807  return WriteAnalogLTCOutput (inLTCOutput, rp188data);
3808 }
3809 
3810 
3811 bool CNTV2Card::WriteAnalogLTCOutput (const UWord inLTCOutput, const NTV2_RP188 & inRP188Data)
3812 {
3813  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3814  return false;
3815 
3816  return WriteRegister (inLTCOutput == 0 ? kRegLTCAnalogBits0_31 : kRegLTC2AnalogBits0_31, inRP188Data.fLo)
3817  && WriteRegister (inLTCOutput == 0 ? kRegLTCAnalogBits32_63 : kRegLTC2AnalogBits32_63, inRP188Data.fHi);
3818 }
3819 
3820 
3821 bool CNTV2Card::GetAnalogLTCOutClockChannel (const UWord inLTCOutput, NTV2Channel & outChannel)
3822 {
3823  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3824  return false;
3825 
3826  ULWord value(0);
3827  bool isMultiFormat(false);
3828  if (!GetMultiFormatMode(isMultiFormat))
3829  return false;
3830  if (!isMultiFormat)
3831  return false;
3832  if (!ReadRegister(kRegLTCStatusControl, value, 0x7, inLTCOutput ? 20 : 16)) // Bits 16|17|18 for LTCOut1, bits 20|21|22 for LTCOut2
3833  return false;
3834  outChannel = NTV2Channel(value + 1);
3835  return true;
3836 }
3837 
3838 
3839 bool CNTV2Card::SetAnalogLTCOutClockChannel (const UWord inLTCOutput, const NTV2Channel inChannel)
3840 {
3841  if (ULWord(inLTCOutput) >= GetNumSupported(kDeviceGetNumLTCOutputs))
3842  return false;
3843  if (IS_CHANNEL_INVALID (inChannel))
3844  return false;
3845  bool isMultiFormat(false);
3846  if (!GetMultiFormatMode(isMultiFormat))
3847  return false;
3848  if (!isMultiFormat)
3849  return false;
3850  return WriteRegister (kRegLTCStatusControl, inChannel - 1, 0x7, inLTCOutput ? 20 : 16); // Bits 16|17|18 for LTCOut1, bits 20|21|22 for LTCOut2
3851 }
3852 
3853 
3854 static const ULWord sSDIXmitEnableMasks[] = { kRegMaskSDI1Transmit, kRegMaskSDI2Transmit, kRegMaskSDI3Transmit, ULWord(kRegMaskSDI4Transmit),
3855  kRegMaskSDI5Transmit, kRegMaskSDI6Transmit, kRegMaskSDI7Transmit, kRegMaskSDI8Transmit};
3856 static const ULWord sSDIXmitEnableShifts[] = { kRegShiftSDI1Transmit, kRegShiftSDI2Transmit, kRegShiftSDI3Transmit, kRegShiftSDI4Transmit,
3857  kRegShiftSDI5Transmit, kRegShiftSDI6Transmit, kRegShiftSDI7Transmit, kRegShiftSDI8Transmit};
3858 
3859 bool CNTV2Card::SetSDITransmitEnable (const NTV2Channel inChannel, const bool inEnable)
3860 {
3861  if (IS_CHANNEL_INVALID(inChannel))
3862  return false; // bad channel
3863  if (!IsSupported(kDeviceHasBiDirectionalSDI))
3864  return true; // no bidirectional SDI, OK
3865  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3866  return false; // no such SDI connector
3867  const ULWord mask(sSDIXmitEnableMasks[inChannel]), shift(sSDIXmitEnableShifts[inChannel]);
3868  return WriteRegister(kRegSDITransmitControl, ULWord(inEnable), mask, shift);
3869 }
3870 
3871 bool CNTV2Card::SetSDITransmitEnable (const NTV2ChannelSet & inSDIConnectors, const bool inEnable)
3872 {
3873  UWord failures(0);
3874  for (NTV2ChannelSetConstIter it(inSDIConnectors.begin()); it != inSDIConnectors.end(); ++it)
3875  if (!SetSDITransmitEnable(*it, inEnable))
3876  failures++;
3877  return !failures;
3878 }
3879 
3880 bool CNTV2Card::GetSDITransmitEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3881 {
3882  if (IS_CHANNEL_INVALID(inChannel))
3883  return false; // invalid channel
3884  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3885  return false; // no such SDI connector
3886  if (!IsSupported(kDeviceHasBiDirectionalSDI))
3887  {outIsEnabled = true; return true;} // no bidirectional SDI, enabled, OK
3888  const ULWord mask(sSDIXmitEnableMasks[inChannel]), shift(sSDIXmitEnableShifts[inChannel]);
3889  return CNTV2DriverInterface::ReadRegister (kRegSDITransmitControl, outIsEnabled, mask, shift);
3890 }
3891 
3892 bool CNTV2Card::GetTransmitSDIs (NTV2ChannelSet & outXmitSDIs)
3893 {
3894  outXmitSDIs.clear();
3895  const bool biDirectionalSDI (IsSupported(kDeviceHasBiDirectionalSDI));
3896  const NTV2Channel maxCh(NTV2Channel(GetNumSupported(kDeviceGetNumVideoOutputs)));
3897  bool isXmit(false);
3898  for (NTV2Channel ch(NTV2_CHANNEL1); ch < maxCh; ch = NTV2Channel(ch+1))
3899  if (!biDirectionalSDI || (GetSDITransmitEnable(ch, isXmit) && isXmit))
3900  outXmitSDIs.insert(ch);
3901  return true;
3902 }
3903 
3904 
3905 bool CNTV2Card::SetSDIOut2Kx1080Enable (NTV2Channel inChannel, const bool inIsEnabled)
3906 {
3907  if (IS_CHANNEL_INVALID (inChannel))
3908  return false;
3909  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inIsEnabled, kK2RegMaskSDI1Out_2Kx1080Mode, kK2RegShiftSDI1Out_2Kx1080Mode);
3910 }
3911 
3912 bool CNTV2Card::GetSDIOut2Kx1080Enable(NTV2Channel inChannel, bool & outIsEnabled)
3913 {
3914  if (IS_CHANNEL_INVALID (inChannel))
3915  return false;
3916  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kK2RegMaskSDI1Out_2Kx1080Mode, kK2RegShiftSDI1Out_2Kx1080Mode);
3917 }
3918 
3919 bool CNTV2Card::SetSDIOut3GEnable (const NTV2Channel inChannel, const bool inEnable)
3920 {
3921  if (IS_CHANNEL_INVALID(inChannel))
3922  return false;
3923  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inEnable, kLHIRegMaskSDIOut3GbpsMode, kLHIRegShiftSDIOut3GbpsMode);
3924 }
3925 
3926 bool CNTV2Card::GetSDIOut3GEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3927 {
3928  if (IS_CHANNEL_INVALID(inChannel))
3929  return false;
3930  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kLHIRegMaskSDIOut3GbpsMode, kLHIRegShiftSDIOut3GbpsMode);
3931 }
3932 
3933 
3934 bool CNTV2Card::SetSDIOut3GbEnable (const NTV2Channel inChannel, const bool inEnable)
3935 {
3936  if (IS_CHANNEL_INVALID(inChannel))
3937  return false;
3938  return WriteRegister (gChannelToSDIOutControlRegNum[inChannel], inEnable, kLHIRegMaskSDIOutSMPTELevelBMode, kLHIRegShiftSDIOutSMPTELevelBMode);
3939 }
3940 
3941 bool CNTV2Card::GetSDIOut3GbEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3942 {
3943  if (IS_CHANNEL_INVALID(inChannel))
3944  return false;
3945  return CNTV2DriverInterface::ReadRegister (gChannelToSDIOutControlRegNum[inChannel], outIsEnabled, kLHIRegMaskSDIOutSMPTELevelBMode, kLHIRegShiftSDIOutSMPTELevelBMode);
3946 }
3947 
3948 bool CNTV2Card::SetSDIOut6GEnable (const NTV2Channel inChannel, const bool inEnable)
3949 {
3950  if (IS_CHANNEL_INVALID(inChannel))
3951  return false;
3952  const NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3953  if (inEnable)
3954  WriteRegister(gChannelToSDIOutControlRegNum[channel], 0, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3955  return WriteRegister(gChannelToSDIOutControlRegNum[channel], inEnable, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode);
3956 }
3957 
3958 bool CNTV2Card::GetSDIOut6GEnable (const NTV2Channel inChannel, bool & outIsEnabled)
3959 {
3960  if (IS_CHANNEL_INVALID(inChannel))
3961  return false;
3962  bool is6G(false), is12G(false);
3963  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3964  const bool result (CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], is6G, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode)
3965  && CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], is12G, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode));
3966  if (is6G && !is12G)
3967  outIsEnabled = true;
3968  else
3969  outIsEnabled = false;
3970  return result;
3971 }
3972 
3973 bool CNTV2Card::SetSDIOut12GEnable (const NTV2Channel inChannel, const bool inEnable)
3974 {
3975  if (IS_CHANNEL_INVALID(inChannel))
3976  return false;
3977  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3978  if (inEnable)
3979  WriteRegister(gChannelToSDIOutControlRegNum[channel], 0, kRegMaskSDIOut6GbpsMode, kRegShiftSDIOut6GbpsMode);
3980  return WriteRegister(gChannelToSDIOutControlRegNum[channel], inEnable, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3981 }
3982 
3983 bool CNTV2Card::GetSDIOut12GEnable(const NTV2Channel inChannel, bool & outIsEnabled)
3984 {
3985  if (IS_CHANNEL_INVALID(inChannel))
3986  return false;
3987  NTV2Channel channel (IsSupported(kDeviceCanDo12gRouting) ? inChannel : NTV2_CHANNEL3);
3988  return CNTV2DriverInterface::ReadRegister(gChannelToSDIOutControlRegNum[channel], outIsEnabled, kRegMaskSDIOut12GbpsMode, kRegShiftSDIOut12GbpsMode);
3989 }
3990 
3991 
3992 bool CNTV2Card::GetSDIOutputAudioSystem (const NTV2Channel inChannel, NTV2AudioSystem & outAudioSystem)
3993 {
3994  outAudioSystem = NTV2_AUDIOSYSTEM_INVALID;
3995  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
3996  return false; // illegal channel
3997 
3998  ULWord readVal;
3999  const ULWord regNum (gChannelToSDIOutControlRegNum[inChannel]);
4000  if (!ReadRegister (regNum, readVal, kK2RegMaskSDIOutDS1AudioSelect, kK2RegShiftSDIOutDS1AudioSelect))
4001  return false;
4002 
4003  readVal <<= kK2RegShiftSDIOutDS1AudioSelect;
4004  ULWord b2 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit2) ? 1 : 0;
4005  ULWord b1 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit1) ? 1 : 0;
4006  ULWord b0 = (readVal & kK2RegMaskSDIOutDS1Audio_Bit0) ? 1 : 0;
4007 
4008  outAudioSystem = NTV2AudioSystem(b2 * 4 + b1 * 2 + b0);
4009  return true;
4010 
4011 } // GetSDIOutputAudioSystem
4012 
4013 
4014 bool CNTV2Card::SetSDIOutputAudioSystem (const NTV2Channel inChannel, const NTV2AudioSystem inAudioSystem)
4015 {
4016 
4017  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4018  return false; // Invalid channel
4019  if (ULWord(inAudioSystem) >= GetNumSupported(kDeviceGetTotalNumAudioSystems))
4020  return false; // Invalid audio system
4021 
4022  // shift each bit from it's position in inAudioSystem to it's position in the register
4023  // bit 18 (MSB), bit 28, bit 30 (LSB)
4024  ULWord b2 = (inAudioSystem << 16) & kK2RegMaskSDIOutDS1Audio_Bit2;
4025  ULWord b1 = (inAudioSystem << 27) & kK2RegMaskSDIOutDS1Audio_Bit1;
4026  ULWord b0 = (inAudioSystem << 30) & kK2RegMaskSDIOutDS1Audio_Bit0;
4027 
4028  return WriteRegister (gChannelToSDIOutControlRegNum [inChannel], (b2 | b1 | b0) >> kK2RegShiftSDIOutDS1AudioSelect ,
4029  kK2RegMaskSDIOutDS1AudioSelect, kK2RegShiftSDIOutDS1AudioSelect);
4030 
4031 } // SetSDIOutputAudioSystem
4032 
4033 
4034 bool CNTV2Card::SetSDIOutputAudioSystem (const NTV2ChannelSet & inSDIOutputs, const NTV2AudioSystem inAudioSystem, const bool inDS2)
4035 {
4036  size_t numFailures(0);
4037  for (NTV2ChannelSet::const_iterator it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4038  if (!(inDS2 ? SetSDIOutputDS2AudioSystem(*it, inAudioSystem) : SetSDIOutputAudioSystem(*it, inAudioSystem)))
4039  numFailures++;
4040  return numFailures == 0;
4041 }
4042 
4043 
4044 bool CNTV2Card::GetSDIOutputDS2AudioSystem (const NTV2Channel inChannel, NTV2AudioSystem & outAudioSystem)
4045 {
4046  outAudioSystem = NTV2_AUDIOSYSTEM_INVALID;
4047  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4048  return false; // illegal channel
4049 
4050  ULWord readVal;
4051  const ULWord regNum (gChannelToSDIOutControlRegNum[inChannel]);
4052  if (!ReadRegister (regNum, readVal, kK2RegMaskSDIOutDS2AudioSelect, kK2RegShiftSDIOutDS2AudioSelect))
4053  return false;
4054 
4055  readVal <<= kK2RegShiftSDIOutDS2AudioSelect;
4056  ULWord b2 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit2) ? 1 : 0;
4057  ULWord b1 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit1) ? 1 : 0;
4058  ULWord b0 = (readVal & kK2RegMaskSDIOutDS2Audio_Bit0) ? 1 : 0;
4059 
4060  outAudioSystem = NTV2AudioSystem(b2 * 4 + b1 * 2 + b0);
4061  return true;
4062 
4063 } // GetSDIOutputDS2AudioSystem
4064 
4065 
4066 bool CNTV2Card::SetSDIOutputDS2AudioSystem (const NTV2Channel inChannel, const NTV2AudioSystem inAudioSystem)
4067 {
4068  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumVideoOutputs))
4069  return false; // Invalid channel
4070  if (ULWord(inAudioSystem) >= GetNumSupported(kDeviceGetTotalNumAudioSystems))
4071  return false; // Invalid audio system
4072 
4073  // shift each bit from it's position in inAudioSystem to it's position in the register
4074  // bit 19 (MSB), bit 29, bit 31 (LSB)
4075  ULWord b2 = (inAudioSystem << 17) & kK2RegMaskSDIOutDS2Audio_Bit2;
4076  ULWord b1 = (inAudioSystem << 28) & kK2RegMaskSDIOutDS2Audio_Bit1;
4077  ULWord b0 = (inAudioSystem << 31) & kK2RegMaskSDIOutDS2Audio_Bit0;
4078 
4079  return WriteRegister (gChannelToSDIOutControlRegNum [inChannel], (b2 | b1 | b0) >> kK2RegShiftSDIOutDS2AudioSelect ,
4080  kK2RegMaskSDIOutDS2AudioSelect, kK2RegShiftSDIOutDS2AudioSelect);
4081 
4082 } // SetSDIOutputDS2AudioSystem
4083 
4084 
4085 // SDI bypass relay control
4086 static bool WriteWatchdogControlBit (CNTV2Card & card, const ULWord inValue, const ULWord inMask, const ULWord inShift)
4087 {
4088  if (!card.KickSDIWatchdog())
4089  return false;
4090  return card.WriteRegister (kRegSDIWatchdogControlStatus, inValue, inMask, inShift);
4091 }
4092 
4093 
4094 bool CNTV2Card::KickSDIWatchdog()
4095 {
4096  if (!IsSupported(kDeviceHasSDIRelays))
4097  return false;
4098  // Write 0x01234567 into Kick2 register to begin watchdog reset, then in < 30 msec,
4099  // write 0xA5A55A5A into Kick1 register to complete the reset...
4100  const bool status (WriteRegister(kRegSDIWatchdogKick2, 0x01234567));
4101  return status && WriteRegister(kRegSDIWatchdogKick1, 0xA5A55A5A);
4102 }
4103 
4104 bool CNTV2Card::GetSDIWatchdogStatus (NTV2RelayState & outValue)
4105 {
4106  outValue = NTV2_RELAY_STATE_INVALID;
4107  if (!IsSupported(kDeviceHasSDIRelays))
4108  return false;
4109  ULWord statusBit(0);
4110  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit, kRegMaskSDIWatchdogStatus, kRegShiftSDIWatchdogStatus))
4111  return false;
4112  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4113  return true;
4114 }
4115 
4116 bool CNTV2Card::GetSDIRelayPosition (NTV2RelayState & outValue, const UWord inIndex0)
4117 {
4118  ULWord statusBit(0);
4119  outValue = NTV2_RELAY_STATE_INVALID;
4120  if (!IsSupported(kDeviceHasSDIRelays))
4121  return false;
4122  if (inIndex0 > 1)
4123  return false;
4124  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4125  inIndex0 ? kRegMaskSDIRelayPosition34 : kRegMaskSDIRelayPosition12,
4126  inIndex0 ? kRegShiftSDIRelayPosition34 : kRegShiftSDIRelayPosition12))
4127  return false;
4128  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4129  return true;
4130 }
4131 
4132 bool CNTV2Card::GetSDIRelayManualControl (NTV2RelayState & outValue, const UWord inIndex0)
4133 {
4134  ULWord statusBit(0);
4135  outValue = NTV2_RELAY_STATE_INVALID;
4136  if (!IsSupported(kDeviceHasSDIRelays))
4137  return false;
4138  if (inIndex0 > 1)
4139  return false;
4140  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4141  inIndex0 ? kRegMaskSDIRelayControl34 : kRegMaskSDIRelayControl12,
4142  inIndex0 ? kRegShiftSDIRelayControl34 : kRegShiftSDIRelayControl12))
4143  return false;
4144  outValue = statusBit ? NTV2_THROUGH_DEVICE : NTV2_DEVICE_BYPASSED;
4145  return true;
4146 }
4147 
4148 bool CNTV2Card::SetSDIRelayManualControl (const NTV2RelayState inValue, const UWord inIndex0)
4149 {
4150  const ULWord statusBit ((inValue == NTV2_THROUGH_DEVICE) ? 1 : 0);
4151  if (!IsSupported(kDeviceHasSDIRelays))
4152  return false;
4153  if (inIndex0 > 1)
4154  return false;
4155  return WriteWatchdogControlBit (*this, statusBit,
4156  inIndex0 ? kRegMaskSDIRelayControl34 : kRegMaskSDIRelayControl12,
4157  inIndex0 ? kRegShiftSDIRelayControl34 : kRegShiftSDIRelayControl12);
4158 }
4159 
4160 bool CNTV2Card::GetSDIWatchdogEnable (bool & outValue, const UWord inIndex0)
4161 {
4162  ULWord statusBit(0);
4163  outValue = false;
4164  if (!IsSupported(kDeviceHasSDIRelays))
4165  return false;
4166  if (inIndex0 > 1)
4167  return false;
4168  if (!ReadRegister (kRegSDIWatchdogControlStatus, statusBit,
4169  inIndex0 ? kRegMaskSDIWatchdogEnable34 : kRegMaskSDIWatchdogEnable12,
4170  inIndex0 ? kRegShiftSDIWatchdogEnable34 : kRegShiftSDIWatchdogEnable12))
4171  return false;
4172  outValue = statusBit ? true : false;
4173  return true;
4174 }
4175 
4176 bool CNTV2Card::SetSDIWatchdogEnable (const bool inValue, const UWord inIndex0)
4177 {
4178  const ULWord statusBit ((inValue == NTV2_THROUGH_DEVICE) ? 1 : 0);
4179  if (!IsSupported(kDeviceHasSDIRelays))
4180  return false;
4181  if (inIndex0 > 1)
4182  return false;
4183  return WriteWatchdogControlBit (*this, statusBit,
4184  inIndex0 ? kRegMaskSDIWatchdogEnable34 : kRegMaskSDIWatchdogEnable12,
4185  inIndex0 ? kRegShiftSDIWatchdogEnable34 : kRegShiftSDIWatchdogEnable12);
4186 }
4187 
4188 bool CNTV2Card::GetSDIWatchdogTimeout (ULWord & outValue)
4189 {
4190  outValue = 0;
4191  if (!IsSupported(kDeviceHasSDIRelays))
4192  return false;
4193  return ReadRegister (kRegSDIWatchdogTimeout, outValue);
4194 }
4195 
4196 bool CNTV2Card::SetSDIWatchdogTimeout (const ULWord inValue)
4197 {
4198  return KickSDIWatchdog() && WriteRegister (kRegSDIWatchdogTimeout, inValue);
4199 }
4200 
4201 bool CNTV2Card::Enable4KDCRGBMode(bool enable)
4202 {
4203  return WriteRegister(kRegDC1, enable, kRegMask4KDCRGBMode, kRegShift4KDCRGBMode);
4204 }
4205 
4206 bool CNTV2Card::GetEnable4KDCRGBMode(bool & outIsEnabled)
4207 {
4208  ULWord tempVal (0);
4209  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCRGBMode, kRegShift4KDCRGBMode));
4210  outIsEnabled = static_cast <bool> (tempVal);
4211  return retVal;
4212 }
4213 
4214 bool CNTV2Card::Enable4KDCYCC444Mode(bool enable)
4215 {
4216  return WriteRegister(kRegDC1, enable, kRegMask4KDCYCC444Mode, kRegShift4KDCYCC444Mode);
4217 }
4218 
4219 bool CNTV2Card::GetEnable4KDCYCC444Mode(bool & outIsEnabled)
4220 {
4221  ULWord tempVal (0);
4222  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCYCC444Mode, kRegShift4KDCYCC444Mode));
4223  outIsEnabled = static_cast <bool> (tempVal);
4224  return retVal;
4225 }
4226 
4227 bool CNTV2Card::Enable4KDCPSFInMode(bool enable)
4228 {
4229  return WriteRegister(kRegDC1, enable, kRegMask4KDCPSFInMode, kRegShift4KDCPSFInMode);
4230 }
4231 
4232 bool CNTV2Card::GetEnable4KDCPSFInMode(bool & outIsEnabled)
4233 {
4234  ULWord tempVal (0);
4235  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCPSFInMode, kRegShift4KDCPSFInMode));
4236  outIsEnabled = static_cast <bool> (tempVal);
4237  return retVal;
4238 }
4239 
4240 bool CNTV2Card::Enable4KPSFOutMode(bool enable)
4241 {
4242  return WriteRegister(kRegDC1, enable, kRegMask4KDCPSFOutMode, kRegShift4KDCPSFOutMode);
4243 }
4244 
4245 bool CNTV2Card::GetEnable4KPSFOutMode(bool & outIsEnabled)
4246 {
4247  ULWord tempVal (0);
4248  const bool retVal (ReadRegister (kRegDC1, tempVal, kRegMask4KDCPSFOutMode, kRegShift4KDCPSFOutMode));
4249  outIsEnabled = static_cast <bool> (tempVal);
4250  return retVal;
4251 }
4252 
4253 
4254 bool CNTV2Card::GetSDITRSError (const NTV2Channel inChannel)
4255 {
4256  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4257  return 0;
4258  if (IS_CHANNEL_INVALID(inChannel))
4259  return 0;
4260  ULWord value(0);
4261  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInTRSError, kRegShiftSDIInTRSError);
4262  return value ? true : false;
4263 }
4264 
4265 bool CNTV2Card::GetSDILock (const NTV2Channel inChannel)
4266 {
4267  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4268  return 0;
4269  if (IS_CHANNEL_INVALID(inChannel))
4270  return 0;
4271  ULWord value(0);
4272  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInLocked, kRegShiftSDIInLocked);
4273  return value ? true : false;
4274 }
4275 
4276 ULWord CNTV2Card::GetSDIUnlockCount (const NTV2Channel inChannel)
4277 {
4278  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4279  return 0;
4280  if (IS_CHANNEL_INVALID(inChannel))
4281  return 0;
4282  ULWord value(0);
4283  ReadRegister(gChannelToRXSDIStatusRegs[inChannel], value, kRegMaskSDIInUnlockCount, kRegShiftSDIInUnlockCount);
4284  return value;
4285 }
4286 
4287 ULWord CNTV2Card::GetCRCErrorCountA (const NTV2Channel inChannel)
4288 {
4289  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4290  return 0;
4291  if (IS_CHANNEL_INVALID(inChannel))
4292  return 0;
4293  ULWord value(0);
4294  ReadRegister(gChannelToRXSDICRCErrorCountRegs[inChannel], value, kRegMaskSDIInCRCErrorCountA, kRegShiftSDIInCRCErrorCountA);
4295  return value;
4296 }
4297 
4298 ULWord CNTV2Card::GetCRCErrorCountB (const NTV2Channel inChannel)
4299 {
4300  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4301  return 0;
4302  if (IS_CHANNEL_INVALID(inChannel))
4303  return 0;
4304  ULWord value(0);
4305  ReadRegister(gChannelToRXSDICRCErrorCountRegs[inChannel], value, kRegMaskSDIInCRCErrorCountB, kRegShiftSDIInCRCErrorCountB);
4306  return value;
4307 }
4308 
4309 bool CNTV2Card::SetSDIInLevelBtoLevelAConversion (const UWord inInputSpigot, const bool inEnable)
4310 {
4311  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4312  return false;
4313  if (IS_INPUT_SPIGOT_INVALID (inInputSpigot))
4314  return false;
4315 
4316  ULWord regNum, mask, shift;
4317  switch (inInputSpigot)
4318  {
4319  case NTV2_CHANNEL1: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn1LevelBtoLevelA; shift = kRegShiftSDIIn1LevelBtoLevelA; break;
4320  case NTV2_CHANNEL2: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn2LevelBtoLevelA; shift = kRegShiftSDIIn2LevelBtoLevelA; break;
4321  case NTV2_CHANNEL3: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn3LevelBtoLevelA; shift = kRegShiftSDIIn3LevelBtoLevelA; break;
4322  case NTV2_CHANNEL4: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn4LevelBtoLevelA; shift = kRegShiftSDIIn4LevelBtoLevelA; break;
4323  case NTV2_CHANNEL5: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn5LevelBtoLevelA; shift = kRegShiftSDIIn5LevelBtoLevelA; break;
4324  case NTV2_CHANNEL6: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn6LevelBtoLevelA; shift = kRegShiftSDIIn6LevelBtoLevelA; break;
4325  case NTV2_CHANNEL7: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn7LevelBtoLevelA; shift = kRegShiftSDIIn7LevelBtoLevelA; break;
4326  case NTV2_CHANNEL8: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn8LevelBtoLevelA; shift = kRegShiftSDIIn8LevelBtoLevelA; break;
4327  default: return false;
4328  }
4329  return WriteRegister(regNum, inEnable, mask, shift);
4330 }
4331 
4332 bool CNTV2Card::SetSDIInLevelBtoLevelAConversion (const NTV2ChannelSet & inSDIInputs, const bool inEnable)
4333 {
4334  size_t errors(0);
4335  for (NTV2ChannelSetConstIter it(inSDIInputs.begin()); it != inSDIInputs.end(); ++it)
4336  if (!SetSDIInLevelBtoLevelAConversion(*it, inEnable))
4337  errors++;
4338  return !errors;
4339 }
4340 
4341 bool CNTV2Card::GetSDIInLevelBtoLevelAConversion (const UWord inInputSpigot, bool & outEnabled)
4342 {
4343  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4344  return false;
4345  if (IS_INPUT_SPIGOT_INVALID (inInputSpigot))
4346  return false;
4347 
4348  ULWord regNum, mask, shift;
4349  switch (inInputSpigot)
4350  {
4351  case NTV2_CHANNEL1: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn1LevelBtoLevelA; shift = kRegShiftSDIIn1LevelBtoLevelA; break;
4352  case NTV2_CHANNEL2: regNum = kRegSDIInput3GStatus; mask = kRegMaskSDIIn2LevelBtoLevelA; shift = kRegShiftSDIIn2LevelBtoLevelA; break;
4353  case NTV2_CHANNEL3: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn3LevelBtoLevelA; shift = kRegShiftSDIIn3LevelBtoLevelA; break;
4354  case NTV2_CHANNEL4: regNum = kRegSDIInput3GStatus2; mask = kRegMaskSDIIn4LevelBtoLevelA; shift = kRegShiftSDIIn4LevelBtoLevelA; break;
4355  case NTV2_CHANNEL5: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn5LevelBtoLevelA; shift = kRegShiftSDIIn5LevelBtoLevelA; break;
4356  case NTV2_CHANNEL6: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn6LevelBtoLevelA; shift = kRegShiftSDIIn6LevelBtoLevelA; break;
4357  case NTV2_CHANNEL7: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn7LevelBtoLevelA; shift = kRegShiftSDIIn7LevelBtoLevelA; break;
4358  case NTV2_CHANNEL8: regNum = kRegSDI5678Input3GStatus; mask = kRegMaskSDIIn8LevelBtoLevelA; shift = kRegShiftSDIIn8LevelBtoLevelA; break;
4359  default: return false;
4360  }
4361  return CNTV2DriverInterface::ReadRegister (regNum, outEnabled, mask, shift);
4362 }
4363 
4364 bool CNTV2Card::SetSDIOutLevelAtoLevelBConversion (const UWord inOutputSpigot, const bool inEnable)
4365 {
4366  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4367  return false;
4368  if (IS_OUTPUT_SPIGOT_INVALID(inOutputSpigot))
4369  return false;
4370 
4371  return WriteRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], inEnable, kRegMaskSDIOutLevelAtoLevelB, kRegShiftSDIOutLevelAtoLevelB);
4372 }
4373 
4374 bool CNTV2Card::SetSDIOutLevelAtoLevelBConversion (const NTV2ChannelSet & inSDIOutputs, const bool inEnable)
4375 {
4376  size_t errors(0);
4377  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4378  if (!SetSDIOutLevelAtoLevelBConversion(*it, inEnable))
4379  errors++;
4380  return !errors;
4381 }
4382 
4383 bool CNTV2Card::GetSDIOutLevelAtoLevelBConversion (const UWord inOutputSpigot, bool & outEnable)
4384 {
4385  if (!IsSupported(kDeviceCanDo3GLevelConversion))
4386  return false;
4387  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4388  return false;
4389 
4390  ULWord tempVal (0);
4391  const bool retVal (ReadRegister (gChannelToSDIOutControlRegNum[inOutputSpigot], tempVal, kRegMaskSDIOutLevelAtoLevelB, kRegShiftSDIOutLevelAtoLevelB));
4392  outEnable = static_cast <bool> (tempVal);
4393  return retVal;
4394 }
4395 
4396 bool CNTV2Card::SetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, const bool inEnable)
4397 {
4398  if (!IsSupported(kDeviceCanDoRGBLevelAConversion))
4399  return false;
4400  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4401  return false;
4402 
4403  return WriteRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], inEnable, kRegMaskRGBLevelA, kRegShiftRGBLevelA);
4404 }
4405 
4406 bool CNTV2Card::SetSDIOutRGBLevelAConversion (const NTV2ChannelSet & inSDIOutputs, const bool inEnable)
4407 {
4408  size_t errors(0);
4409  for (NTV2ChannelSetConstIter it(inSDIOutputs.begin()); it != inSDIOutputs.end(); ++it)
4410  if (!SetSDIOutRGBLevelAConversion(*it, inEnable))
4411  errors++;
4412  return !errors;
4413 }
4414 
4415 bool CNTV2Card::GetSDIOutRGBLevelAConversion(const UWord inOutputSpigot, bool & outEnable)
4416 {
4417  if (!IsSupported(kDeviceCanDoRGBLevelAConversion))
4418  return false;
4419  if (IS_OUTPUT_SPIGOT_INVALID (inOutputSpigot))
4420  return false;
4421 
4422  ULWord tempVal(0);
4423  const bool retVal(ReadRegister(gChannelToSDIOutControlRegNum[inOutputSpigot], tempVal, kRegMaskRGBLevelA, kRegShiftRGBLevelA));
4424  outEnable = static_cast <bool> (tempVal);
4425  return retVal;
4426 }
4427 
4428 bool CNTV2Card::SetMultiFormatMode (const bool inEnable)
4429 {
4430  if (!IsSupported(kDeviceCanDoMultiFormat))
4431  return false;
4432 
4433  return WriteRegister (kRegGlobalControl2, inEnable ? 1 : 0, kRegMaskIndependentMode, kRegShiftIndependentMode);
4434 }
4435 
4436 bool CNTV2Card::GetMultiFormatMode (bool & outEnabled)
4437 {
4438  return IsSupported(kDeviceCanDoMultiFormat)
4439  ? CNTV2DriverInterface::ReadRegister (kRegGlobalControl2, outEnabled, kRegMaskIndependentMode, kRegShiftIndependentMode)
4440  : false;
4441 }
4442 
4443 bool CNTV2Card::SetRS422Parity (const NTV2Channel inChannel, const NTV2_RS422_PARITY inParity)
4444 {
4445  if (!IsSupported(kDeviceCanDoProgrammableRS422))
4446  return false; // Non-programmable RS422
4447  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4448  return false;
4449  if (inParity == NTV2_RS422_NO_PARITY)
4450  {
4451  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], 1, kRegMaskRS422ParityDisable, kRegShiftRS422ParityDisable);
4452  }
4453  else
4454  {
4455  ULWord tempVal (0);
4456  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal))
4457  return false;
4458 
4459  tempVal &= ~kRegMaskRS422ParityDisable;
4460  switch (inParity)
4461  {
4462  case NTV2_RS422_ODD_PARITY: tempVal &= ~kRegMaskRS422ParitySense; break;
4463  case NTV2_RS422_EVEN_PARITY: tempVal |= kRegMaskRS422ParitySense; break;
4464 
4465  case NTV2_RS422_PARITY_INVALID:
4466  default: return false;
4467  }
4468 
4469  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], tempVal);
4470  }
4471 }
4472 
4473 bool CNTV2Card::GetRS422Parity (const NTV2Channel inChannel, NTV2_RS422_PARITY & outParity)
4474 {
4475  outParity = NTV2_RS422_PARITY_INVALID;
4476  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4477  return false;
4478 
4479  ULWord tempVal (0);
4480  if (IsSupported(kDeviceCanDoProgrammableRS422)) // Read register only if programmable RS422
4481  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal))
4482  return false;
4483 
4484  if (tempVal & kRegMaskRS422ParityDisable)
4485  outParity = NTV2_RS422_NO_PARITY;
4486  else if (tempVal & kRegMaskRS422ParitySense)
4487  outParity = NTV2_RS422_EVEN_PARITY;
4488  else
4489  outParity = NTV2_RS422_ODD_PARITY; // Default
4490 
4491  return true;
4492 }
4493 
4494 bool CNTV2Card::SetRS422BaudRate (const NTV2Channel inChannel, const NTV2_RS422_BAUD_RATE inBaudRate)
4495 {
4496  if (!IsSupported(kDeviceCanDoProgrammableRS422))
4497  return false; // Non-programmable RS422
4498  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4499  return false; // No such serial port
4500 
4501  ULWord tempVal (0);
4502  switch (inBaudRate)
4503  {
4504  case NTV2_RS422_BAUD_RATE_38400: tempVal = 0; break;
4505  case NTV2_RS422_BAUD_RATE_19200: tempVal = 1; break;
4506  case NTV2_RS422_BAUD_RATE_9600: tempVal = 2; break;
4507  case NTV2_RS422_BAUD_RATE_INVALID:
4508  #if !defined(_DEBUG)
4509  default:
4510  #endif
4511  return false;
4512  }
4513  return WriteRegister (gChannelToRS422ControlRegNum [inChannel], tempVal, kRegMaskRS422BaudRate, kRegShiftRS422BaudRate);
4514 }
4515 
4516 bool CNTV2Card::GetRS422BaudRate (const NTV2Channel inChannel, NTV2_RS422_BAUD_RATE & outBaudRate)
4517 {
4518  outBaudRate = NTV2_RS422_BAUD_RATE_INVALID;
4519  if (ULWord(inChannel) >= GetNumSupported(kDeviceGetNumSerialPorts))
4520  return false; // No such serial port
4521 
4522  ULWord tempVal (0); // Default to 38400
4523  if (IsSupported(kDeviceCanDoProgrammableRS422)) // Read register only if programmable RS422
4524  if (!ReadRegister (gChannelToRS422ControlRegNum[inChannel], tempVal, kRegMaskRS422BaudRate, kRegShiftRS422BaudRate))
4525  return false; // ReadRegister failed
4526 
4527  switch (tempVal)
4528  {
4529  case 0: outBaudRate = NTV2_RS422_BAUD_RATE_38400; break;
4530  case 1: outBaudRate = NTV2_RS422_BAUD_RATE_19200; break;
4531  case 2: outBaudRate = NTV2_RS422_BAUD_RATE_9600; break;
4532  default: return false;
4533  }
4534  return true;
4535 }
4536 
4537 bool CNTV2Card::AcquireMailBoxLock()
4538 {
4539  ULWord val = 0;
4540  ReadRegister(kVRegMailBoxAcquire, val);
4541  return val;
4542 }
4543 
4544 bool CNTV2Card::ReleaseMailBoxLock()
4545 {
4546  ULWord val = 0;
4547  ReadRegister(kVRegMailBoxRelease, val);
4548  return val;
4549 }
4550 
4551 bool CNTV2Card::AbortMailBoxLock()
4552 {
4553  ULWord val = 0;
4554  ReadRegister(kVRegMailBoxAbort, val);
4555  return val;
4556 }
4557 
4558 bool CNTV2Card::GetDieTemperature (double & outTemp, const NTV2DieTempScale inTempScale)
4559 {
4560  outTemp = 0.0;
4561 
4562  // Read the temperature...
4563  ULWord rawRegValue (0);
4564  if (!ReadRegister (kRegSysmonVccIntDieTemp, rawRegValue))
4565  return false;
4566 
4567  double celsius (0);
4568  if (IsSupported(kDeviceCanDoVersalSysMon))
4569  {
4570  UWord dieTempRaw (rawRegValue & 0x0000FFFF);
4571  celsius = double (dieTempRaw) / 128.0;
4572  }
4573  else
4574  {
4575  UWord dieTempRaw ((rawRegValue & 0x0000FFFF) >> 6);
4576  celsius = (double (dieTempRaw) * 503.975 / 1024.0 - 273.15);
4577  }
4578  switch (inTempScale)
4579  {
4580  case NTV2DieTempScale_Celsius: outTemp = celsius; break;
4581  case NTV2DieTempScale_Fahrenheit: outTemp = celsius * 9.0 / 5.0 + 32.0; break;
4582  case NTV2DieTempScale_Kelvin: outTemp = celsius + 273.15; break;
4583  case NTV2DieTempScale_Rankine: outTemp = (celsius + 273.15) * 9.0 / 5.0; break;
4584  default: return false;
4585  }
4586  return true;
4587 }
4588 
4589 bool CNTV2Card::GetDieVoltage (double & outVoltage)
4590 {
4591  outVoltage = 0.0;
4592 
4593  // Read the Vcc voltage...
4594  ULWord rawRegValue (0);
4595  if (!ReadRegister (kRegSysmonVccIntDieTemp, rawRegValue))
4596  return false;
4597 
4598  const UWord coreVoltageRaw ((rawRegValue>>22) & 0x00003FF);
4599  const double coreVoltageFloat (double(coreVoltageRaw)/ 1024.0 * 3.0);
4600  outVoltage = coreVoltageFloat;
4601  return true;
4602 }
4603 
4604 bool CNTV2Card::SetWarmBootFirmwareReload(bool enable)
4605 {
4606  bool canReboot = false;
4607  CanWarmBootFPGA(canReboot);
4608  if(!canReboot)
4609  return false;
4610  return WriteRegister(kRegCPLDVersion, enable ? 1:0, BIT(8), 8);
4611 }
4612 
4613 #if defined(READREGMULTICHANGE)
4614  bool CNTV2Card::ReadRegisters (const NTV2RegNumSet & inRegisters, NTV2RegisterValueMap & outValues)
4615  {
4616  outValues.clear ();
4617  if (!IsOpen())
4618  return false; // Device not open!
4619  if (inRegisters.empty())
4620  return false; // Nothing to do!
4621 
4622  NTV2GetRegisters getRegsParams (inRegisters);
4623  if (NTV2Message(getRegsParams))
4624  {
4625  if (!getRegsParams.GetRegisterValues(outValues))
4626  return false;
4627  }
4628  else // Non-atomic user-space workaround until GETREGS implemented in driver...
4629  for (NTV2RegNumSetConstIter iter(inRegisters.begin()); iter != inRegisters.end(); ++iter)
4630  {
4631  ULWord tempVal (0);
4632  if (*iter != kRegXenaxFlashDOUT) // Prevent firmware erase/program/verify failures
4633  if (ReadRegister (*iter, tempVal))
4634  outValues[*iter] = tempVal;
4635  }
4636  return outValues.size() == inRegisters.size();
4637  }
4638 #endif // !defined(READREGMULTICHANGE)
4639 
4640 
4641 bool CNTV2Card::WriteRegisters (const NTV2RegisterWrites & inRegWrites)
4642 {
4643  if (!_boardOpened)
4644  return false; // Device not open!
4645  if (inRegWrites.empty())
4646  return true; // Nothing to do!
4647 
4648  bool result(false);
4649  NTV2SetRegisters setRegsParams(inRegWrites);
4650  //cerr << "## DEBUG: CNTV2Card::WriteRegisters: setRegsParams: " << setRegsParams << endl;
4651  result = NTV2Message(setRegsParams);
4652  if (!result)
4653  {
4654  // Non-atomic user-space workaround until SETREGS implemented in driver...
4655  const NTV2RegInfo * pRegInfos = setRegsParams.mInRegInfos;
4656  UWord * pBadNdxs = setRegsParams.mOutBadRegIndexes;
4657  for (ULWord ndx(0); ndx < setRegsParams.mInNumRegisters; ndx++)
4658  if (!WriteRegister(pRegInfos[ndx].registerNumber, pRegInfos[ndx].registerValue, pRegInfos[ndx].registerMask, pRegInfos[ndx].registerShift))
4659  pBadNdxs[setRegsParams.mOutNumFailures++] = UWord(ndx);
4660  result = true;
4661  }
4662  if (result && setRegsParams.mInNumRegisters && setRegsParams.mOutNumFailures)
4663  result = false; // fail if any writes failed
4664  if (!result) CVIDFAIL("Failed: setRegsParams: " << setRegsParams);
4665  return result;
4666 }
4667 
4668 bool CNTV2Card::BankSelectWriteRegister (const NTV2RegInfo & inBankSelect, const NTV2RegInfo & inRegInfo)
4669 {
4670  NTV2BankSelGetSetRegs bankSelGetSetMsg (inBankSelect, inRegInfo, true);
4671  //cerr << "## DEBUG: CNTV2Card::BankSelectWriteRegister: " << bankSelGetSetMsg << endl;
4672  if (!NTV2Message(bankSelGetSetMsg))
4673  // Fall back to doing 2 ops & hope nobody else clobbers the bank select register...
4674  return WriteRegister(inBankSelect.registerNumber, inBankSelect.registerValue, inBankSelect.registerMask, inBankSelect.registerShift)
4675  && WriteRegister(inRegInfo.registerNumber, inRegInfo.registerValue, inRegInfo.registerMask, inRegInfo.registerShift);
4676  return true;
4677 }
4678 
4679 bool CNTV2Card::BankSelectReadRegister (const NTV2RegInfo & inBankSelect, NTV2RegInfo & inOutRegInfo)
4680 {
4681  NTV2BankSelGetSetRegs bankSelGetSetMsg (inBankSelect, inOutRegInfo);
4682  //cerr << "## DEBUG: CNTV2Card::BankSelectReadRegister: " << bankSelGetSetMsg << endl;
4683  if (!NTV2Message(bankSelGetSetMsg))
4684  // Fall back to doing 2 ops & hope nobody else clobbers the bank select register...
4685  return WriteRegister(inBankSelect.registerNumber, inBankSelect.registerValue, inBankSelect.registerMask, inBankSelect.registerShift)
4686  && ReadRegister(inOutRegInfo.registerNumber, inOutRegInfo.registerValue, inOutRegInfo.registerMask, inOutRegInfo.registerShift);
4687  if (bankSelGetSetMsg.mInRegInfos)
4688  inOutRegInfo = bankSelGetSetMsg.GetRegInfo();
4689  return true;
4690 }
4691 
4692 bool CNTV2Card::WriteVirtualData (const ULWord inTag, const void* inVirtualData, const ULWord inVirtualDataSize)
4693 {
4694  NTV2VirtualData virtualDataMsg (inTag, inVirtualData, inVirtualDataSize, true);
4695  //cerr << "## DEBUG: CNTV2Card::WriteVirtualData: " << virtualDataMsg << endl;
4696  return NTV2Message(virtualDataMsg);
4697 }
4698 
4699 bool CNTV2Card::ReadVirtualData (const ULWord inTag, void* outVirtualData, const ULWord inVirtualDataSize)
4700 {
4701  NTV2VirtualData virtualDataMsg (inTag, outVirtualData, inVirtualDataSize, false);
4702  //cerr << "## DEBUG: CNTV2Card::ReadVirtualData: " << virtualDataMsg << endl;
4703  return NTV2Message(virtualDataMsg);
4704 }
4705 
4706 bool CNTV2Card::ReadSDIStatistics (NTV2SDIInStatistics & outStats)
4707 {
4708  outStats.Clear ();
4709  if (!_boardOpened)
4710  return false; // Device not open!
4711  if (!IsSupported(kDeviceCanDoSDIErrorChecks))
4712  return false; // Device doesn't support it!
4713  if (!NTV2Message(reinterpret_cast<NTV2_HEADER*>(&outStats)))
4714  {
4715  const ULWord numSDIInputs(GetNumSupported(kDeviceGetNumVideoInputs));
4716  NTV2RegisterReads sdiStatRegInfos;
4717  for (size_t sdi(0); sdi < numSDIInputs; sdi++)
4718  for (ULWord reg(0); reg < 6; reg++)
4719  sdiStatRegInfos.push_back(NTV2RegInfo(reg + gChannelToRXSDIStatusRegs[sdi]));
4720  sdiStatRegInfos.push_back(NTV2RegInfo(kRegRXSDIFreeRunningClockLow));
4721  sdiStatRegInfos.push_back(NTV2RegInfo(kRegRXSDIFreeRunningClockHigh));
4722  // Read the registers all at once...
4723  if (!ReadRegisters(sdiStatRegInfos))
4724  return false;
4725  // Stuff the results into outStats...
4726  for (size_t sdi(0); sdi < numSDIInputs; sdi++)
4727  {
4728  NTV2SDIInputStatus & outStat(outStats[sdi]);
4729  size_t ndx(sdi*6 + 0); // Start at kRegRXSDINStatus register
4730  NTV2_ASSERT(ndx < sdiStatRegInfos.size());
4731  NTV2RegInfo & regInfo(sdiStatRegInfos.at(ndx));
4732  NTV2_ASSERT(regInfo.registerNumber == gChannelToRXSDIStatusRegs[sdi]);
4733  outStat.mUnlockTally = regInfo.registerValue & kRegMaskSDIInUnlockCount;
4734  outStat.mLocked = regInfo.registerValue & kRegMaskSDIInLocked ? true : false;
4735  outStat.mFrameTRSError = regInfo.registerValue & kRegMaskSDIInTRSError ? true : false;
4736  outStat.mVPIDValidA = regInfo.registerValue & kRegMaskSDIInVpidValidA ? true : false;
4737  outStat.mVPIDValidB = regInfo.registerValue & kRegMaskSDIInVpidValidB ? true : false;
4738  regInfo = sdiStatRegInfos.at(ndx+1); // kRegRXSDINCRCErrorCount
4739  outStat.mCRCTallyA = regInfo.registerValue & kRegMaskSDIInCRCErrorCountA;
4740  outStat.mCRCTallyB = (regInfo.registerValue & kRegMaskSDIInCRCErrorCountB) >> kRegShiftSDIInCRCErrorCountB;
4741  // kRegRXSDINFrameCountHigh kRegRXSDINFrameCountLow
4742  //outStat.mFrameTally = (ULWord64(sdiStatRegInfos.at(ndx+2).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(ndx+1).registerValue);
4743  // kRegRXSDINFrameRefCountHigh kRegRXSDINFrameRefCountLow
4744  outStat.mFrameRefClockCount = (ULWord64(sdiStatRegInfos.at(ndx+5).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(ndx+4).registerValue);
4745  // kRegRXSDIFreeRunningClockHigh kRegRXSDIFreeRunningClockLow
4746  outStat.mGlobalClockCount = (ULWord64(sdiStatRegInfos.at(8*6+1).registerValue) << 32) | ULWord64(sdiStatRegInfos.at(8*6+0).registerValue);
4747  } // for each SDI input
4748  }
4749  return true;
4750 }
4751 
4752 bool CNTV2Card::SetMultiRasterBypassEnable (const bool inEnable)
4753 {
4754  return HasMultiRasterWidget() && WriteRegister(kRegMROutControl, inEnable, kRegMaskMRBypass, kRegShiftMRBypass);
4755 }
4756 
4757 bool CNTV2Card::GetMultiRasterBypassEnable (bool & outEnabled)
4758 {
4759  if (!HasMultiRasterWidget())
4760  return false;
4761  NTV2ULWordVector regs; regs.push_back(0); regs.push_back(0); regs.push_back(0); regs.push_back(0);
4762  if (!ReadRegister(kRegMRQ1Control, regs.at(0))
4763  || !ReadRegister(kRegMRQ2Control, regs.at(1))
4764  || !ReadRegister(kRegMRQ3Control, regs.at(2))
4765  || !ReadRegister(kRegMRQ4Control, regs.at(3)))
4766  return false;
4767  // Any enabled quadrant means the 4K frame is being written by the hardware
4768  outEnabled = (regs.at(0) & kRegMaskMREnable)
4769  || (regs.at(1) & kRegMaskMREnable)
4770  || (regs.at(2) & kRegMaskMREnable)
4771  || (regs.at(3) & kRegMaskMREnable);
4772 // CNTV2DriverInterface::ReadRegister(kRegMROutControl, outEnabled, kRegMaskMRBypass, kRegShiftMRBypass);
4773  return true;
4774 }
4775 
4776 bool CNTV2Card::IsMultiRasterWidgetChannel (const NTV2Channel inChannel)
4777 {
4778  return HasMultiRasterWidget() && inChannel == NTV2Channel(GetNumSupported(kDeviceGetNumVideoChannels));
4779 }
4780 
4781 
4783 
4784 #ifdef MSWindows
4785 #pragma warning(default: 4800)
4786 #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:2703
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:1468
gSDIOutToRP188Input
static const ULWord gSDIOutToRP188Input[]
Definition: ntv2register.cpp:2642
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:4332
kRegSDIOut4Control
@ kRegSDIOut4Control
Definition: ntv2publicinterface.h:308
NTV2_FORMAT_3840x2160p_6000
@ NTV2_FORMAT_3840x2160p_6000
Definition: ntv2enums.h:648
kRegGlobalControlCh5
@ kRegGlobalControlCh5
Definition: ntv2publicinterface.h:548
BIT_3
#define BIT_3
Definition: ajatypes.h:597
kRegSDIWatchdogTimeout
@ kRegSDIWatchdogTimeout
Definition: ntv2publicinterface.h:458
kVRegProgressivePicture
@ kVRegProgressivePicture
Definition: ntv2virtualregisters.h:223
NTV2_FORMAT_4096x2160psf_2500
@ NTV2_FORMAT_4096x2160psf_2500
Definition: ntv2enums.h:656
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:3045
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:4558
NTV2_FORMAT_625_5000
@ NTV2_FORMAT_625_5000
Definition: ntv2enums.h:576
kRegCh8Control
@ kRegCh8Control
Definition: ntv2publicinterface.h:568
NTV2_FORMAT_4x1920x1080p_6000
@ NTV2_FORMAT_4x1920x1080p_6000
Definition: ntv2enums.h:612
gChannelToSDIInputProgressiveMask
static const ULWord gChannelToSDIInputProgressiveMask[]
Definition: ntv2register.cpp:170
SSC_GET_FIRMWARE_PROGRESS_STRUCT::programTotalSize
ULWord programTotalSize
Definition: ntv2publicinterface.h:5072
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:4428
NTV2_INPUTSOURCE_SDI4
@ NTV2_INPUTSOURCE_SDI4
Identifies the 4th SDI video input.
Definition: ntv2enums.h:1268
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:3665
NTV2_FG_4x2048x1080
@ NTV2_FG_4x2048x1080
4096x2160, for 4K, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:365
NTV2VANCModeFromBools
#define NTV2VANCModeFromBools(_tall_, _taller_)
Definition: ntv2enums.h:3795
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:638
NTV2_FORMAT_1080psf_2398
@ NTV2_FORMAT_1080psf_2398
Definition: ntv2enums.h:548
kRegMask4KDCPSFInMode
@ kRegMask4KDCPSFInMode
Definition: ntv2publicinterface.h:2107
CNTV2Card::SetPCIAccessFrame
virtual bool SetPCIAccessFrame(const NTV2Channel inChannel, const ULWord inValue, const bool inWaitForVBI=(!(0)))
Definition: ntv2register.cpp:2227
NTV2SDIInputStatus::mVPIDValidB
bool mVPIDValidB
If true, at least one valid SMPTE 352 packet was received over the last four VBI periods.
Definition: ntv2publicinterface.h:7122
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:4116
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:2033
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:688
LWord
int32_t LWord
Definition: ajatypes.h:275
CNTV2Card::GetSDIOut12GEnable
virtual bool GetSDIOut12GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3983
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:658
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:252
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:7116
NTV2_IS_VANCMODE_TALLER
#define NTV2_IS_VANCMODE_TALLER(__v__)
Definition: ntv2enums.h:3792
NTV2RegNumSetConstIter
ULWordSetConstIter NTV2RegNumSetConstIter
A const iterator that iterates over a set of distinct NTV2RegisterNumbers.
Definition: ntv2publicinterface.h:7662
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:4473
NTV2_FORMAT_2K_1498
@ NTV2_FORMAT_2K_1498
Definition: ntv2enums.h:583
NTV2RegisterValueMap
std::map< ULWord, ULWord > NTV2RegisterValueMap
A mapping of distinct NTV2RegisterNumbers to their corresponding ULWord values.
Definition: ntv2publicinterface.h:7679
NTV2_FORMAT_720p_5000
@ NTV2_FORMAT_720p_5000
Definition: ntv2enums.h:559
NTV2_NUM_STANDARDS
@ NTV2_NUM_STANDARDS
Definition: ntv2enums.h:179
NTV2_RELAY_STATE_INVALID
@ NTV2_RELAY_STATE_INVALID
Definition: ntv2enums.h:3926
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:449
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:3731
NTV2FrameGeometryToString
std::string NTV2FrameGeometryToString(const NTV2FrameGeometry inValue, const bool inForRetailDisplay=false)
defined(NTV2_DEPRECATE_17_6)
Definition: ntv2utils.cpp:7305
NTV2_CHANNEL8
@ NTV2_CHANNEL8
Specifies channel or FrameStore 8 (or the 8th item).
Definition: ntv2enums.h:1362
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:1270
NTV2_FORMAT_2K_2400
@ NTV2_FORMAT_2K_2400
Definition: ntv2enums.h:586
NTV2_RP188_INVALID
@ NTV2_RP188_INVALID
Definition: ntv2enums.h:2096
NTV2_IS_VALID_NTV2FrameGeometry
#define NTV2_IS_VALID_NTV2FrameGeometry(__s__)
Definition: ntv2enums.h:376
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:169
NTV2_REFERENCE_SFP1_PTP
@ NTV2_REFERENCE_SFP1_PTP
Specifies the PTP source on SFP 1.
Definition: ntv2enums.h:1464
NTV2_FORMAT_4x4096x2160p_4800
@ NTV2_FORMAT_4x4096x2160p_4800
Definition: ntv2enums.h:707
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:2533
kRegMaskHDMIInV2VideoStd
@ kRegMaskHDMIInV2VideoStd
Definition: ntv2publicinterface.h:1619
kRegMixer1Coefficient
@ kRegMixer1Coefficient
Definition: ntv2publicinterface.h:131
NTV2_IS_VALID_TASK_MODE
#define NTV2_IS_VALID_TASK_MODE(__m__)
Definition: ntv2publicinterface.h:4474
gChannelToOutputTimingCtrlRegNum
static const ULWord gChannelToOutputTimingCtrlRegNum[]
Definition: ntv2register.cpp:88
NTV2TaskMode
NTV2TaskMode
Describes the task mode state. See also: Sharing AJA Devices With Other Applications.
Definition: ntv2publicinterface.h:4462
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:7121
CNTV2Card::SetWarmBootFirmwareReload
virtual bool SetWarmBootFirmwareReload(bool enable)
Definition: ntv2register.cpp:4604
CNTV2Card::SetSDIOut2Kx1080Enable
virtual bool SetSDIOut2Kx1080Enable(const NTV2Channel inChannel, const bool inIsEnabled)
Definition: ntv2register.cpp:3905
NTV2MIXERMODE_INVALID
@ NTV2MIXERMODE_INVALID
Invalid/uninitialized.
Definition: ntv2enums.h:1793
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:1356
NTV2_VANCDATA_NORMAL
@ NTV2_VANCDATA_NORMAL
Definition: ntv2enums.h:3800
NTV2_FORMAT_4x4096x2160p_2398
@ NTV2_FORMAT_4x4096x2160p_2398
Definition: ntv2enums.h:701
CNTV2Card::GetForce64
virtual bool GetForce64(ULWord *force64)
Definition: ntv2register.cpp:3251
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:3919
NTV2_FORMAT_525_5994
@ NTV2_FORMAT_525_5994
Definition: ntv2enums.h:575
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:4094
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:3073
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:351
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:4176
CNTV2Card::SetFrameBufferQuarterSizeMode
virtual bool SetFrameBufferQuarterSizeMode(NTV2Channel inChannel, NTV2QuarterSizeExpandMode inValue)
Definition: ntv2register.cpp:1937
gChannelToSDIInputRateShift
static const ULWord gChannelToSDIInputRateShift[]
Definition: ntv2register.cpp:156
CNTV2Card::GetSDIOut3GEnable
virtual bool GetSDIOut3GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3926
CNTV2Card::GetRegisterBaseAddress
virtual bool GetRegisterBaseAddress(ULWord regNumber, ULWord **pRegAddress)
Definition: ntv2register.cpp:3182
ntv2devicefeatures.h
Declares device capability functions.
NTV2_FG_720x576
@ NTV2_FG_720x576
720x576, for PAL 625i, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:350
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:353
CNTV2Card::AcquireMailBoxLock
virtual bool AcquireMailBoxLock(void)
Definition: ntv2register.cpp:4537
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:2554
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:498
kK2RegMaskXena2VidProcMode
@ kK2RegMaskXena2VidProcMode
Definition: ntv2publicinterface.h:1957
NTV2_FORMAT_4096x2160p_2500
@ NTV2_FORMAT_4096x2160p_2500
Definition: ntv2enums.h:659
kRegShiftSDIIn16GbpsMode
@ kRegShiftSDIIn16GbpsMode
Definition: ntv2publicinterface.h:3045
CNTV2Card::GetPCIAccessFrame
virtual bool GetPCIAccessFrame(const NTV2Channel inChannel, ULWord &outValue)
Definition: ntv2register.cpp:2237
NTV2_FRAMERATE_1500
@ NTV2_FRAMERATE_1500
15 frames per second
Definition: ntv2enums.h:424
kRegShiftSDIRelayPosition34
@ kRegShiftSDIRelayPosition34
Definition: ntv2publicinterface.h:3161
NTV2_FRAMERATE_6000
@ NTV2_FRAMERATE_6000
60 frames per second
Definition: ntv2enums.h:411
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:3025
kRegOutputTimingControlch7
@ kRegOutputTimingControlch7
Definition: ntv2publicinterface.h:673
NTV2_INPUTSOURCE_SDI7
@ NTV2_INPUTSOURCE_SDI7
Identifies the 7th SDI video input.
Definition: ntv2enums.h:1271
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:4199
kRegInput78Status
@ kRegInput78Status
Definition: ntv2publicinterface.h:644
GetNTV2FrameGeometryFromVideoFormat
NTV2FrameGeometry GetNTV2FrameGeometryFromVideoFormat(const NTV2VideoFormat inVideoFormat)
Definition: ntv2utils.cpp:2644
NTV2_REFERENCE_SFP2_PCR
@ NTV2_REFERENCE_SFP2_PCR
Specifies the PCR source on SFP 2.
Definition: ntv2enums.h:1467
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:2969
NTV2_FORMAT_525psf_2997
@ NTV2_FORMAT_525psf_2997
Definition: ntv2enums.h:579
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They're also commonly use...
Definition: ntv2enums.h:1353
NTV2_FG_4x4096x2160
@ NTV2_FG_4x4096x2160
8192x4320, for 8K, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:369
kRegShiftRP188ModeCh4
@ kRegShiftRP188ModeCh4
Definition: ntv2publicinterface.h:2370
kRegShiftSDIOut12GbpsMode
@ kRegShiftSDIOut12GbpsMode
Definition: ntv2publicinterface.h:2759
GetQuarterSizedGeometry
NTV2FrameGeometry GetQuarterSizedGeometry(const NTV2FrameGeometry inGeometry)
Definition: ntv2utils.cpp:2315
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:616
NTV2DeviceCanDo25GIP
bool NTV2DeviceCanDo25GIP(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:581
CNTV2Card::GetDieVoltage
virtual bool GetDieVoltage(double &outVoltage)
Reads the current "Vcc" voltage of the device.
Definition: ntv2register.cpp:4589
kRegMaskSDIIn612GbpsMode
@ kRegMaskSDIIn612GbpsMode
Definition: ntv2publicinterface.h:2022
NTV2_REFERENCE_INPUT7
@ NTV2_REFERENCE_INPUT7
Specifies the SDI In 7 connector.
Definition: ntv2enums.h:1462
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:205
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:3321
kRegShiftInput2FrameRate
@ kRegShiftInput2FrameRate
Definition: ntv2publicinterface.h:2507
NTV2_FORMAT_4096x2160psf_2398
@ NTV2_FORMAT_4096x2160psf_2398
Definition: ntv2enums.h:654
CNTV2Card::SetFrameBufferOrientation
virtual bool SetFrameBufferOrientation(const NTV2Channel inChannel, const NTV2FBOrientation inValue)
Sets the frame buffer orientation for the given NTV2Channel.
Definition: ntv2register.cpp:2011
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:181
NTV2_ASSERT
#define NTV2_ASSERT(_expr_)
Definition: ajatypes.h:529
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:163
NTV2_STANDARD_3840x2160p
@ NTV2_STANDARD_3840x2160p
Identifies Ultra-High-Definition (UHD)
Definition: ntv2enums.h:171
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:415
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:3630
NTV2_VIDEOLIMITING_LEGALSDI
@ NTV2_VIDEOLIMITING_LEGALSDI
Identifies the "Legal SDI" mode (Ymax=0x3AC, Cmax=0x3C0)
Definition: ntv2enums.h:3765
SSC_GET_FIRMWARE_PROGRESS_STRUCT::programProgress
ULWord programProgress
Definition: ntv2publicinterface.h:5073
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:3007
kRegMixer4Coefficient
@ kRegMixer4Coefficient
Definition: ntv2publicinterface.h:681
CNTV2Card::GetEnable4KPSFOutMode
virtual bool GetEnable4KPSFOutMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4245
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:166
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:2960
CNTV2Card::GetSDI1OutHTiming
virtual bool GetSDI1OutHTiming(ULWord *value)
Definition: ntv2register.cpp:3396
kRegShiftForce64
@ kRegShiftForce64
Definition: ntv2publicinterface.h:2527
NTV2_FORMAT_1080psf_2K_2398
@ NTV2_FORMAT_1080psf_2K_2398
Definition: ntv2enums.h:557
kRegShiftSDIOut6GbpsMode
@ kRegShiftSDIOut6GbpsMode
Definition: ntv2publicinterface.h:2758
CNTV2Card::IsXilinxProgrammed
virtual bool IsXilinxProgrammed()
Definition: ntv2register.cpp:2307
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:2584
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:3856
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:2992
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:3758
NTV2_FG_2048x1080
@ NTV2_FG_2048x1080
2048x1080, for 2Kx1080p, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:357
kRegShiftRP188ModeCh7
@ kRegShiftRP188ModeCh7
Definition: ntv2publicinterface.h:2373
NTV2_STANDARD_4096HFR
@ NTV2_STANDARD_4096HFR
Identifies high frame-rate 4K.
Definition: ntv2enums.h:174
gChannelToSmpte372RegisterNum
static const ULWord gChannelToSmpte372RegisterNum[]
Definition: ntv2register.cpp:126
NTV2_STANDARD_4096x2160p
@ NTV2_STANDARD_4096x2160p
Identifies 4K.
Definition: ntv2enums.h:172
CNTV2Card::GetInputVideoSelect
virtual bool GetInputVideoSelect(NTV2InputVideoSelect &outInputSelect)
Definition: ntv2register.cpp:3420
kRegMaskInput2GeometryHigh
@ kRegMaskInput2GeometryHigh
Definition: ntv2publicinterface.h:1428
NTV2_FORMAT_1080p_2K_4800_A
@ NTV2_FORMAT_1080p_2K_4800_A
Definition: ntv2enums.h:628
NTV2_FORMAT_4x2048x1080p_11988
@ NTV2_FORMAT_4x2048x1080p_11988
Definition: ntv2enums.h:618
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:7814
kRegCh1Control2MFrame
@ kRegCh1Control2MFrame
Definition: ntv2publicinterface.h:694
NTV2_FG_INVALID
@ NTV2_FG_INVALID
Definition: ntv2enums.h:373
NTV2_FRAMERATE_12000
@ NTV2_FRAMERATE_12000
120 frames per second
Definition: ntv2enums.h:422
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:2680
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:544
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:2653
kRegShiftQuadQuadSquaresMode
@ kRegShiftQuadQuadSquaresMode
Definition: ntv2publicinterface.h:2380
CNTV2Card::SetSDIOut6GEnable
virtual bool SetSDIOut6GEnable(const NTV2Channel inChannel, const bool inEnable)
Definition: ntv2register.cpp:3948
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:3560
kRegMaskRP188SourceSelect
@ kRegMaskRP188SourceSelect
Definition: ntv2publicinterface.h:1431
NTV2_FRAMERATE_INVALID
@ NTV2_FRAMERATE_INVALID
Definition: ntv2enums.h:437
ntv2endian.h
Defines a number of handy byte-swapping macros.
CNTV2Card::GetEnable4KDCYCC444Mode
virtual bool GetEnable4KDCYCC444Mode(bool &outIsEnabled)
Definition: ntv2register.cpp:4219
kRegShiftSDIIn23GbpsMode
@ kRegShiftSDIIn23GbpsMode
Definition: ntv2publicinterface.h:3047
kRegMaskVidProcBGMatteEnable
@ kRegMaskVidProcBGMatteEnable
Definition: ntv2publicinterface.h:1346
NTV2_FORMAT_4x1920x1080psf_3000
@ NTV2_FORMAT_4x1920x1080psf_3000
Definition: ntv2enums.h:605
NTV2_FRAMEBUFFER_ORIENTATION_NORMAL
@ NTV2_FRAMEBUFFER_ORIENTATION_NORMAL
Definition: ntv2enums.h:2044
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:2122
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:2377
NTV2_FORMAT_1080p_2K_3000
@ NTV2_FORMAT_1080p_2K_3000
Definition: ntv2enums.h:625
NTV2_FORMAT_4096x2160psf_2997
@ NTV2_FORMAT_4096x2160psf_2997
Definition: ntv2enums.h:662
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:606
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:4160
kRegMaskSmpte372Enable
@ kRegMaskSmpte372Enable
Definition: ntv2publicinterface.h:1241
CNTV2Card::DisableChannel
virtual bool DisableChannel(const NTV2Channel inChannel)
Disables the given FrameStore.
Definition: ntv2register.cpp:2140
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:7065
NTV2_IS_QUAD_QUAD_FRAME_GEOMETRY
#define NTV2_IS_QUAD_QUAD_FRAME_GEOMETRY(geom)
Definition: ntv2enums.h:378
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:3701
CNTV2Card::GetSDIOut6GEnable
virtual bool GetSDIOut6GEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3958
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:5071
NTV2_FORMAT_4x4096x2160p_2500
@ NTV2_FORMAT_4x4096x2160p_2500
Definition: ntv2enums.h:703
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:5771
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:2281
CNTV2Card::SetDualLinkInputEnable
virtual bool SetDualLinkInputEnable(const bool inIsEnabled)
Definition: ntv2register.cpp:3219
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:706
kRegMask425FB12
@ kRegMask425FB12
Definition: ntv2publicinterface.h:1272
GetQuarterSizedStandard
NTV2Standard GetQuarterSizedStandard(const NTV2Standard inGeometry)
Definition: ntv2utils.cpp:2340
NTV2_FORMAT_4x1920x1080p_2997
@ NTV2_FORMAT_4x1920x1080p_2997
Definition: ntv2enums.h:602
NTV2_FORMAT_4x1920x1080p_2500
@ NTV2_FORMAT_4x1920x1080p_2500
Definition: ntv2enums.h:595
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:2634
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:2254
kRegRP188InOut5DBB
@ kRegRP188InOut5DBB
Definition: ntv2publicinterface.h:497
kRegGlobalControlCh7
@ kRegGlobalControlCh7
Definition: ntv2publicinterface.h:550
NTV2_FBF_INVALID
@ NTV2_FBF_INVALID
Definition: ntv2enums.h:253
NTV2_FORMAT_4x2048x1080p_4800
@ NTV2_FORMAT_4x2048x1080p_4800
Definition: ntv2enums.h:617
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:215
NTV2_FORMAT_4x3840x2160p_2500
@ NTV2_FORMAT_4x3840x2160p_2500
Definition: ntv2enums.h:690
WriteWatchdogControlBit
static bool WriteWatchdogControlBit(CNTV2Card &card, const ULWord inValue, const ULWord inMask, const ULWord inShift)
Definition: ntv2register.cpp:4086
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:208
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:1466
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:349
kRegMaskQuadQuadMode
@ kRegMaskQuadQuadMode
Definition: ntv2publicinterface.h:1287
CNTV2Card::SetSDI1OutHTiming
virtual bool SetSDI1OutHTiming(ULWord value)
Definition: ntv2register.cpp:3395
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:2791
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:1805
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:4436
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:4132
CNTV2Card::SupportsP2PTransfer
virtual bool SupportsP2PTransfer(void)
Definition: ntv2register.cpp:2468
CNTV2Card::GetLTCEmbeddedOutEnable
virtual bool GetLTCEmbeddedOutEnable(bool &outValue)
Definition: ntv2register.cpp:3752
CNTV2VPID::GetProgressivePicture
virtual bool GetProgressivePicture(void) const
Definition: ntv2vpid.cpp:346
NTV2_IS_QUAD_STANDARD
#define NTV2_IS_QUAD_STANDARD(__s__)
Definition: ntv2enums.h:204
AJA_UNUSED
#define AJA_UNUSED(_x_)
Definition: types.h:424
CNTV2Card::FlipFlopPage
virtual bool FlipFlopPage(const NTV2Channel inChannel)
Definition: ntv2register.cpp:2243
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:3109
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::SetTaskMode
virtual bool SetTaskMode(const NTV2TaskMode inMode)
Sets the device's task mode.
Definition: ntv2register.cpp:179
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:3354
kRegShiftLED
@ kRegShiftLED
Definition: ntv2publicinterface.h:2335
NTV2_CHANNEL1
@ NTV2_CHANNEL1
Specifies channel or FrameStore 1 (or the first item).
Definition: ntv2enums.h:1355
CNTV2Card::ReadFlashProgramControl
virtual bool ReadFlashProgramControl(ULWord &outValue)
Definition: ntv2register.cpp:2298
NTV2RelayState
NTV2RelayState
This enumerated data type identifies the two possible states of the bypass relays....
Definition: ntv2enums.h:3921
NTV2_IS_2K_1080_FRAME_GEOMETRY
#define NTV2_IS_2K_1080_FRAME_GEOMETRY(geom)
Definition: ntv2enums.h:384
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:1856
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:3859
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:688
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:3880
kRegMaskDualLinkOutEnable
@ kRegMaskDualLinkOutEnable
Definition: ntv2publicinterface.h:1247
NTV2FrameSize
Describes the horizontal and vertical size dimensions of a raster, bitmap, frame or image.
Definition: ntv2publicinterface.h:5816
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:2863
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:1919
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:7117
kRegMaskSDIIn63GbpsMode
@ kRegMaskSDIIn63GbpsMode
Definition: ntv2publicinterface.h:2016
CNTV2Card::GetEnable4KDCPSFInMode
virtual bool GetEnable4KDCPSFInMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4232
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:180
CNTV2Card::GetXena2FlashBaseAddress
virtual bool GetXena2FlashBaseAddress(ULWord **pXena2FlashAddress)
Definition: ntv2register.cpp:3197
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:3912
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:416
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:627
CNTV2Card::Enable4KDCYCC444Mode
virtual bool Enable4KDCYCC444Mode(bool inEnable)
Sets 4K Down Convert YCC 444 mode.
Definition: ntv2register.cpp:4214
NTV2_FORMAT_3840x2160p_2500
@ NTV2_FORMAT_3840x2160p_2500
Definition: ntv2enums.h:641
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:408
kVRegFlashSize
@ kVRegFlashSize
Definition: ntv2virtualregisters.h:301
NTV2_INPUTSOURCE_HDMI3
@ NTV2_INPUTSOURCE_HDMI3
Identifies the 3rd HDMI video input.
Definition: ntv2enums.h:1263
kRegMaskVidProcRGBRange
@ kRegMaskVidProcRGBRange
Definition: ntv2publicinterface.h:1344
NTV2_CHANNEL6
@ NTV2_CHANNEL6
Specifies channel or FrameStore 6 (or the 6th item).
Definition: ntv2enums.h:1360
NTV2SDIInputStatus
For devices that support it (see NTV2DeviceCanDoSDIErrorChecks ), this struct reports SDI input error...
Definition: ntv2publicinterface.h:7108
CNTV2Card::GetTaskMode
virtual bool GetTaskMode(NTV2TaskMode &outMode)
Retrieves the device's current task mode.
Definition: ntv2register.cpp:184
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:7113
CNTV2Card::WriteRegisters
virtual bool WriteRegisters(const NTV2RegisterWrites &inRegWrites)
Writes the given sequence of NTV2RegInfo's.
Definition: ntv2register.cpp:4641
CNTV2Card::SetFrameBufferQuality
virtual bool SetFrameBufferQuality(NTV2Channel inChannel, NTV2FrameBufferQuality inValue)
Definition: ntv2register.cpp:1957
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:3052
gChannelToSDIInputProgressiveShift
static const ULWord gChannelToSDIInputProgressiveShift[]
Definition: ntv2register.cpp:172
NTV2_FORMAT_2K_2398
@ NTV2_FORMAT_2K_2398
Definition: ntv2enums.h:585
NTV2_FORMAT_4x4096x2160p_2997
@ NTV2_FORMAT_4x4096x2160p_2997
Definition: ntv2enums.h:704
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:7661
NTV2_FRAMERATE_4800
@ NTV2_FRAMERATE_4800
48 frames per second
Definition: ntv2enums.h:420
CNTV2Card::GetRunningFirmwareUserID
virtual bool GetRunningFirmwareUserID(ULWord &outUserID)
Reports the UserID number of the currently-running firmware.
Definition: ntv2register.cpp:2449
kRegShiftAlphaFromInput2
@ kRegShiftAlphaFromInput2
Definition: ntv2publicinterface.h:2399
NTV2MixerKeyerInputControl
NTV2MixerKeyerInputControl
These enum values identify the Mixer/Keyer foreground and background input control values.
Definition: ntv2enums.h:1772
NTV2_FORMAT_4096x2160psf_2400
@ NTV2_FORMAT_4096x2160psf_2400
Definition: ntv2enums.h:655
IsProgressivePicture
bool IsProgressivePicture(const NTV2VideoFormat format)
Definition: ntv2utils.cpp:5388
NTV2_CHANNEL4
@ NTV2_CHANNEL4
Specifies channel or FrameStore 4 (or the 4th item).
Definition: ntv2enums.h:1358
kRegRP188InOut6Bits32_63
@ kRegRP188InOut6Bits32_63
Definition: ntv2publicinterface.h:592
NTV2BankSelGetSetRegs
This is used to atomically perform bank-selected register reads or writes.
Definition: ntv2publicinterface.h:7876
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:4147
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:4044
NTV2_MODE_INPUT
@ NTV2_MODE_INPUT
Input (capture) mode, which writes into device SDRAM.
Definition: ntv2enums.h:1240
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:4265
kRegShiftSDIIn5LevelBtoLevelA
@ kRegShiftSDIIn5LevelBtoLevelA
Definition: ntv2publicinterface.h:3075
kRegMaskEncodeAsPSF
@ kRegMaskEncodeAsPSF
Definition: ntv2publicinterface.h:1318
NTV2DeviceNeedsRoutingSetup
bool NTV2DeviceNeedsRoutingSetup(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8815
kRegMaskAutodetect64
@ kRegMaskAutodetect64
Definition: ntv2publicinterface.h:1436
NTV2_CHANNEL5
@ NTV2_CHANNEL5
Specifies channel or FrameStore 5 (or the 5th item).
Definition: ntv2enums.h:1359
kRegMaskSDIWatchdogEnable12
@ kRegMaskSDIWatchdogEnable12
Definition: ntv2publicinterface.h:2098
NTV2_FRAMERATE_2400
@ NTV2_FRAMERATE_2400
24 frames per second
Definition: ntv2enums.h:417
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:438
CNTV2Card::GetSDIInput6GPresent
virtual bool GetSDIInput6GPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3689
kRegCh2Control
@ kRegCh2Control
Definition: ntv2publicinterface.h:125
NTV2_FORMAT_4x2048x1080psf_2398
@ NTV2_FORMAT_4x2048x1080psf_2398
Definition: ntv2enums.h:596
NTV2_INPUTSOURCE_ANALOG1
@ NTV2_INPUTSOURCE_ANALOG1
Identifies the first analog video input.
Definition: ntv2enums.h:1260
NTV2_IS_3Gb_FORMAT
#define NTV2_IS_3Gb_FORMAT(__f__)
Definition: ntv2enums.h:971
kRegMaskRS422ParityDisable
@ kRegMaskRS422ParityDisable
Definition: ntv2publicinterface.h:1498
NTV2_FORMAT_4x2048x1080p_2398
@ NTV2_FORMAT_4x2048x1080p_2398
Definition: ntv2enums.h:599
kRegShiftSDI3Transmit
@ kRegShiftSDI3Transmit
Definition: ntv2publicinterface.h:3152
CNTV2Card::Enable4KDCPSFInMode
virtual bool Enable4KDCPSFInMode(bool inEnable)
Sets 4K Down Convert PSF in mode.
Definition: ntv2register.cpp:4227
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:4201
kVRegMailBoxAbort
@ kVRegMailBoxAbort
Definition: ntv2virtualregisters.h:415
CNTV2Card::GetPulldownMode
virtual bool GetPulldownMode(NTV2Channel inChannel, bool &outValue)
Definition: ntv2register.cpp:2902
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:1265
kRegRXSDIFreeRunningClockHigh
@ kRegRXSDIFreeRunningClockHigh
Definition: ntv2publicinterface.h:793
NTV2_FRAMESIZE_28MB
@ NTV2_FRAMESIZE_28MB
Definition: ntv2enums.h:2127
NTV2_REFERENCE_HDMI_INPUT4
@ NTV2_REFERENCE_HDMI_INPUT4
Specifies the HDMI In 4 connector.
Definition: ntv2enums.h:1470
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:3609
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:3781
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:3060
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:614
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:7004
kRegMaskSDI7Transmit
@ kRegMaskSDI7Transmit
Definition: ntv2publicinterface.h:2088
HEXN
#define HEXN(__x__, __n__)
Definition: ntv2publicinterface.h:5765
GetNTV2StandardFromScanGeometry
NTV2Standard GetNTV2StandardFromScanGeometry(const UByte inScanGeometry, const bool inIsProgressiveTransport)
Definition: ntv2utils.cpp:1903
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:3069
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:2946
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:1793
YCbCr10BitPixel
Definition: ntv2videodefines.h:200
CNTV2Card::GetVideoDACMode
virtual bool GetVideoDACMode(NTV2VideoDACMode &outValue)
Definition: ntv2register.cpp:3259
NTV2_FORMAT_1080psf_2K_2500
@ NTV2_FORMAT_1080psf_2K_2500
Definition: ntv2enums.h:569
NTV2_REFERENCE_INPUT5
@ NTV2_REFERENCE_INPUT5
Specifies the SDI In 5 connector.
Definition: ntv2enums.h:1460
NTV2_FORMAT_4x2048x1080psf_2400
@ NTV2_FORMAT_4x2048x1080psf_2400
Definition: ntv2enums.h:597
CNTV2Card::SetVideoLimiting
virtual bool SetVideoLimiting(const NTV2VideoLimiting inValue)
Sets the device's video range limiting mode.
Definition: ntv2register.cpp:2672
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:2573
CNTV2Card::SetRP188SourceFilter
virtual bool SetRP188SourceFilter(const NTV2Channel inSDIInput, const UWord inFilterValue)
Sets the RP188 DBB filter for the given SDI input.
Definition: ntv2register.cpp:2596
MAIN_FLASHBLOCK
@ MAIN_FLASHBLOCK
Definition: ntv2enums.h:4261
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:2129
kRegShiftSDIInTRSError
@ kRegShiftSDIInTRSError
Definition: ntv2publicinterface.h:3183
kRegShiftGeometry
@ kRegShiftGeometry
Definition: ntv2publicinterface.h:2330
kDeviceSoftwareCanChangeFrameBufferSize
@ kDeviceSoftwareCanChangeFrameBufferSize
True if device frame buffer size can be changed.
Definition: ntv2devicefeatures.h:110
NTV2_FORMAT_1080p_5994_B
@ NTV2_FORMAT_1080p_5994_B
Definition: ntv2enums.h:561
NTV2_RP188::fHi
ULWord fHi
| BG 8 | Hrs 10 | BG 7 | Hrs 1 | BG 6 | Mins10 | BG 5 | Mins 1 |
Definition: ntv2publicinterface.h:7005
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:2263
kRegCh5OutputFrame
@ kRegCh5OutputFrame
Definition: ntv2publicinterface.h:554
NTV2GetRegisters
This is used by the CNTV2Card::ReadRegisters function.
Definition: ntv2publicinterface.h:7690
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:572
NTV2_FORMAT_1080p_2K_2400
@ NTV2_FORMAT_1080p_2K_2400
Definition: ntv2enums.h:556
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:359
NTV2_RS422_BAUD_RATE_9600
@ NTV2_RS422_BAUD_RATE_9600
9600 baud
Definition: ntv2enums.h:4166
NTV2_FORMAT_525_2398
@ NTV2_FORMAT_525_2398
Definition: ntv2enums.h:577
NTV2_FORMAT_4x2048x1080p_3000
@ NTV2_FORMAT_4x2048x1080p_3000
Definition: ntv2enums.h:607
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:161
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:3784
gIndexToVidProcControlRegNum
static const ULWord gIndexToVidProcControlRegNum[]
Definition: ntv2register.cpp:100
kRegRXSDI4CRCErrorCount
@ kRegRXSDI4CRCErrorCount
Definition: ntv2publicinterface.h:748
BIT_21
#define BIT_21
Definition: ajatypes.h:615
NTV2_FORMAT_4096x2160p_4795
@ NTV2_FORMAT_4096x2160p_4795
Definition: ntv2enums.h:664
CNTV2Card::SetSecondaryVideoFormat
virtual bool SetSecondaryVideoFormat(NTV2VideoFormat inFormat)
Definition: ntv2register.cpp:3402
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:4014
CNTV2Card::SupportsP2PTarget
virtual bool SupportsP2PTarget(void)
Definition: ntv2register.cpp:2490
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:2604
NTV2DieTempScale_Rankine
@ NTV2DieTempScale_Rankine
Definition: ntv2enums.h:4200
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
NTV2_STANDARD_TASKS
@ NTV2_STANDARD_TASKS
1: Standard/Retail: device configured by AJA ControlPanel, service/daemon, and driver.
Definition: ntv2publicinterface.h:4465
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:418
kRegMaskSDIInVpidValidB
@ kRegMaskSDIInVpidValidB
Definition: ntv2publicinterface.h:2120
ULWord
uint32_t ULWord
Definition: ajatypes.h:276
kK2RegMaskSDIOutDS1Audio_Bit0
@ kK2RegMaskSDIOutDS1Audio_Bit0
Definition: ntv2publicinterface.h:1683
NTV2_FORMAT_4x4096x2160p_3000
@ NTV2_FORMAT_4x4096x2160p_3000
Definition: ntv2enums.h:705
CNTV2Card::EnableChannels
virtual bool EnableChannels(const NTV2ChannelSet &inChannels, const bool inDisableOthers=(0))
Enables the given FrameStore(s).
Definition: ntv2register.cpp:2170
kK2RegShiftXena2BgVidProcInputControl
@ kK2RegShiftXena2BgVidProcInputControl
Definition: ntv2publicinterface.h:3019
NTV2_RS422_BAUD_RATE_19200
@ NTV2_RS422_BAUD_RATE_19200
19200 baud
Definition: ntv2enums.h:4165
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:587
NTV2SetRegisters::mInNumRegisters
ULWord mInNumRegisters
The number of NTV2RegInfo's to be set.
Definition: ntv2publicinterface.h:7811
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:3839
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:4188
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:3400
NTV2_CHANNEL7
@ NTV2_CHANNEL7
Specifies channel or FrameStore 7 (or the 7th item).
Definition: ntv2enums.h:1361
kRegShiftVidProcRGBModeSupported
@ kRegShiftVidProcRGBModeSupported
Definition: ntv2publicinterface.h:2442
CNTV2Card::ReleaseMailBoxLock
virtual bool ReleaseMailBoxLock(void)
Definition: ntv2register.cpp:4544
kRegMaskSDIInTsiMuxSyncFail
@ kRegMaskSDIInTsiMuxSyncFail
Definition: ntv2publicinterface.h:1989
NTV2_FORMAT_4x2048x1080psf_3000
@ NTV2_FORMAT_4x2048x1080psf_3000
Definition: ntv2enums.h:609
CNTV2Card::WriteVirtualData
virtual bool WriteVirtualData(const ULWord inTag, const void *inVirtualData, const ULWord inVirtualDataSize)
Writes the block of virtual data.
Definition: ntv2register.cpp:4692
NTV2_FORMAT_1080p_2997
@ NTV2_FORMAT_1080p_2997
Definition: ntv2enums.h:550
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:2406
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:1450
NTV2_FORMAT_1080p_2K_4795_B
@ NTV2_FORMAT_1080p_2K_4795_B
Definition: ntv2enums.h:629
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:2546
kRegMaskSDIIn46GbpsMode
@ kRegMaskSDIIn46GbpsMode
Definition: ntv2publicinterface.h:2005
kRegShiftInput1GeometryHigh
@ kRegShiftInput1GeometryHigh
Definition: ntv2publicinterface.h:2519
NTV2WidgetType_FrameStore
@ NTV2WidgetType_FrameStore
Definition: ntv2enums.h:3037
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:362
NTV2_FRAMERATE_1498
@ NTV2_FRAMERATE_1498
Fractional rate of 15,000 frames per 1,001 seconds.
Definition: ntv2enums.h:425
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:551
kRegCh4PCIAccessFrame
@ kRegCh4PCIAccessFrame
Definition: ntv2publicinterface.h:431
NTV2_FORMAT_4x3840x2160p_5994
@ NTV2_FORMAT_4x3840x2160p_5994
Definition: ntv2enums.h:694
CNTV2Card::GetSDIOut3GbEnable
virtual bool GetSDIOut3GbEnable(const NTV2Channel inChannel, bool &outIsEnabled)
Definition: ntv2register.cpp:3941
NTV2_FORMAT_4096x2160p_2398
@ NTV2_FORMAT_4096x2160p_2398
Definition: ntv2enums.h:657
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:1235
kRegRP188InOut1Bits32_63
@ kRegRP188InOut1Bits32_63
Definition: ntv2publicinterface.h:152
NTV2_FORMAT_720p_6000
@ NTV2_FORMAT_720p_6000
Definition: ntv2enums.h:547
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:2353
NTV2DeviceSoftwareCanChangeFrameBufferSize
bool NTV2DeviceSoftwareCanChangeFrameBufferSize(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8908
NTV2_FORMAT_1080p_2500
@ NTV2_FORMAT_1080p_2500
Definition: ntv2enums.h:552
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:3250
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:4396
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:6521
NTV2_FORMAT_3840x2160psf_3000
@ NTV2_FORMAT_3840x2160psf_3000
Definition: ntv2enums.h:645
CNTV2Card::GetEncodeAsPSF
virtual bool GetEncodeAsPSF(NTV2Channel inChannel, NTV2EncodeAsPSF &outValue)
Definition: ntv2register.cpp:2001
gChannelToRXSDICRCErrorCountRegs
static const ULWord gChannelToRXSDICRCErrorCountRegs[]
Definition: ntv2register.cpp:124
NTV2_FRAMESIZE_4MB
@ NTV2_FRAMESIZE_4MB
Definition: ntv2enums.h:2115
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:3794
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:1269
kRegShiftSDIIn412GbpsMode
@ kRegShiftSDIIn412GbpsMode
Definition: ntv2publicinterface.h:3070
CNTV2Card::GetEnable4KDCRGBMode
virtual bool GetEnable4KDCRGBMode(bool &outIsEnabled)
Definition: ntv2register.cpp:4206
NTV2_FRAMESIZE_30MB
@ NTV2_FRAMESIZE_30MB
Definition: ntv2enums.h:2128
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:3084
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:3821
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:2644
kRegMaskVidProcVANCShift
@ kRegMaskVidProcVANCShift
Definition: ntv2publicinterface.h:1327
NTV2_FORMAT_4x2048x1080p_5000
@ NTV2_FORMAT_4x2048x1080p_5000
Definition: ntv2enums.h:613
kRegGlobalControl2
@ kRegGlobalControl2
Definition: ntv2publicinterface.h:408
NTV2StandardToString
std::string NTV2StandardToString(const NTV2Standard inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6899
NTV2InputCrosspointIDToString
std::string NTV2InputCrosspointIDToString(const NTV2InputCrosspointID inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5811
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:3992
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:668
SAREK_REGS
#define SAREK_REGS
Definition: ntv2registersmb.h:54
NTV2_REFERENCE_INPUT6
@ NTV2_REFERENCE_INPUT6
Specifies the SDI In 6 connector.
Definition: ntv2enums.h:1461
NTV2_FG_720x514
@ NTV2_FG_720x514
720x486, for NTSC 525i and 525p60, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:361
NTV2_FRAMESIZE_20MB
@ NTV2_FRAMESIZE_20MB
Definition: ntv2enums.h:2123
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:3714
NTV2_THROUGH_DEVICE
@ NTV2_THROUGH_DEVICE
Input & output routed through device.
Definition: ntv2enums.h:3924
NTV2_HEADER
All new NTV2 structs start with this common header.
Definition: ntv2publicinterface.h:7196
kRegShiftVidProcLimiting
@ kRegShiftVidProcLimiting
Definition: ntv2publicinterface.h:2434
NTV2_CHANNEL3
@ NTV2_CHANNEL3
Specifies channel or FrameStore 3 (or the 3rd item).
Definition: ntv2enums.h:1357
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:2547
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:167
kRegRP188InOut7Bits0_31
@ kRegRP188InOut7Bits0_31
Definition: ntv2publicinterface.h:601
UWord
uint16_t UWord
Definition: ajatypes.h:274
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:6494
kRegShiftChannelDisable
@ kRegShiftChannelDisable
Definition: ntv2publicinterface.h:2400
kRegSDIOut5Control
@ kRegSDIOut5Control
Definition: ntv2publicinterface.h:491
NTV2_FORMAT_4x1920x1080p_3000
@ NTV2_FORMAT_4x1920x1080p_3000
Definition: ntv2enums.h:603
kRegShift425FB34
@ kRegShift425FB34
Definition: ntv2publicinterface.h:2366
NTV2_FRAMESIZE_12MB
@ NTV2_FRAMESIZE_12MB
Definition: ntv2enums.h:2120
kRegShiftRegClocking
@ kRegShiftRegClocking
Definition: ntv2publicinterface.h:2336
NTV2_IS_VANCMODE_ON
#define NTV2_IS_VANCMODE_ON(__v__)
Definition: ntv2enums.h:3793
NTV2_FORMAT_4x3840x2160p_2997
@ NTV2_FORMAT_4x3840x2160p_2997
Definition: ntv2enums.h:691
NTV2_FBF_8BIT_YCBCR
@ NTV2_FBF_8BIT_YCBCR
See 8-Bit YCbCr Format.
Definition: ntv2enums.h:219
NTV2_REFERENCE_FREERUN
@ NTV2_REFERENCE_FREERUN
Specifies the device's internal clock.
Definition: ntv2enums.h:1455
kRegMaskMRStandard
@ kRegMaskMRStandard
Definition: ntv2publicinterface.h:2280
kRegShiftInput2Progressive
@ kRegShiftInput2Progressive
Definition: ntv2publicinterface.h:2509
NTV2MIXERINPUTCONTROL_INVALID
@ NTV2MIXERINPUTCONTROL_INVALID
Definition: ntv2enums.h:1777
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:3399
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:560
kRegMaskSDIIn812GbpsMode
@ kRegMaskSDIIn812GbpsMode
Definition: ntv2publicinterface.h:2036
NTV2Framesize
NTV2Framesize
Kona2/Xena2 specific enums.
Definition: ntv2enums.h:2112
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:3576
NTV2_FRAMESIZE_10MB
@ NTV2_FRAMESIZE_10MB
Definition: ntv2enums.h:2119
kRegMaskSDIIn3LevelBtoLevelA
@ kRegMaskSDIIn3LevelBtoLevelA
Definition: ntv2publicinterface.h:1995
kRegShiftQuadMode
@ kRegShiftQuadMode
Definition: ntv2publicinterface.h:2348
Get4xSizedGeometry
NTV2FrameGeometry Get4xSizedGeometry(const NTV2FrameGeometry inGeometry)
Definition: ntv2utils.cpp:2328
NTV2_RS422_ODD_PARITY
@ NTV2_RS422_ODD_PARITY
Odd parity – this is the power-up default.
Definition: ntv2enums.h:4150
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:4276
NTV2_FORMAT_4x3840x2160p_5000
@ NTV2_FORMAT_4x3840x2160p_5000
Definition: ntv2enums.h:693
kK2RegShiftXena2FgVidProcInputControl
@ kK2RegShiftXena2FgVidProcInputControl
Definition: ntv2publicinterface.h:3018
NTV2_FORMAT_1080p_2K_5994_A
@ NTV2_FORMAT_1080p_2K_5994_A
Definition: ntv2enums.h:623
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:4383
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:619
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:5074
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:2884
NTV2DieTempScale_Celsius
@ NTV2DieTempScale_Celsius
Definition: ntv2enums.h:4197
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:1457
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:3041
NTV2_FORMAT_625psf_2500
@ NTV2_FORMAT_625psf_2500
Definition: ntv2enums.h:580
kRegMaskSDIRelayControl12
@ kRegMaskSDIRelayControl12
Definition: ntv2publicinterface.h:2096
NTV2WidgetID
NTV2WidgetID
Definition: ntv2enums.h:2905
kRegShiftSDIIn23GbpsSMPTELevelBMode
@ kRegShiftSDIIn23GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:3048
NTV2_INPUTSOURCE_HDMI4
@ NTV2_INPUTSOURCE_HDMI4
Identifies the 4th HDMI video input.
Definition: ntv2enums.h:1264
NTV2DeviceIsDirectAddressable
bool NTV2DeviceIsDirectAddressable(const NTV2DeviceID inDeviceID)
Definition: ntv2devicefeatures.hpp:8533
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:348
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:568
kRegShiftEncodeAsPSF
@ kRegShiftEncodeAsPSF
Definition: ntv2publicinterface.h:2409
kRegMaskMRBypass
@ kRegMaskMRBypass
Definition: ntv2publicinterface.h:2282
NTV2_FORMAT_4x1920x1080psf_2997
@ NTV2_FORMAT_4x1920x1080psf_2997
Definition: ntv2enums.h:604
NTV2_RP188::fDBB
ULWord fDBB
Definition: ntv2publicinterface.h:7003
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:3407
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:567
NTV2_FORMAT_3840x2160psf_2398
@ NTV2_FORMAT_3840x2160psf_2398
Definition: ntv2enums.h:636
NTV2_INPUTSOURCE_HDMI1
@ NTV2_INPUTSOURCE_HDMI1
Identifies the 1st HDMI video input.
Definition: ntv2enums.h:1261
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:3621
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:3428
CNTV2Card::SetDitherFor8BitInputs
virtual bool SetDitherFor8BitInputs(const NTV2Channel inChannel, const ULWord inDither)
Definition: ntv2register.cpp:3234
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:423
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:7812
kRegMaskSDIIn2LevelBtoLevelA
@ kRegMaskSDIIn2LevelBtoLevelA
Definition: ntv2publicinterface.h:1984
NTV2QuarterSizeExpandMode
NTV2QuarterSizeExpandMode
Definition: ntv2enums.h:2482
NTV2_FORMAT_1080p_2K_2398
@ NTV2_FORMAT_1080p_2K_2398
Definition: ntv2enums.h:555
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:642
NTV2_FORMAT_4096x2160p_4800
@ NTV2_FORMAT_4096x2160p_4800
Definition: ntv2enums.h:665
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:553
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:3782
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:4196
kRegSDIOut2Control
@ kRegSDIOut2Control
Definition: ntv2publicinterface.h:264
NTV2_STANDARD_4096i
@ NTV2_STANDARD_4096i
Identifies 4K psf.
Definition: ntv2enums.h:178
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:637
kK2RegMaskSDIOutDS2Audio_Bit1
@ kK2RegMaskSDIOutDS2Audio_Bit1
Definition: ntv2publicinterface.h:1685
NTV2_FORMAT_1080psf_2K_2400
@ NTV2_FORMAT_1080psf_2K_2400
Definition: ntv2enums.h:558
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:1012
NTV2_IS_VALID_CHANNEL
#define NTV2_IS_VALID_CHANNEL(__x__)
Definition: ntv2enums.h:1367
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:4298
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:6507
kRegMaskInput2Geometry
@ kRegMaskInput2Geometry
Definition: ntv2publicinterface.h:1416
NTV2_VANCMODE_INVALID
@ NTV2_VANCMODE_INVALID
This identifies the invalid (unspecified, uninitialized) VANC mode.
Definition: ntv2enums.h:3787
NTV2_FORMAT_3840x2160p_5994
@ NTV2_FORMAT_3840x2160p_5994
Definition: ntv2enums.h:647
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:2937
NTV2_FORMAT_4x4096x2160p_2400
@ NTV2_FORMAT_4x4096x2160p_2400
Definition: ntv2enums.h:702
NTV2BankSelGetSetRegs::mInRegInfos
NTV2Buffer mInRegInfos
NTV2RegInfo array of registers be read/written. The SDK owns this memory.
Definition: ntv2publicinterface.h:7880
kRegCh3OutputFrame
@ kRegCh3OutputFrame
Definition: ntv2publicinterface.h:399
kRegMaskRP188ModeCh6
@ kRegMaskRP188ModeCh6
Definition: ntv2publicinterface.h:1279
ProgramState
ProgramState
Definition: ntv2publicinterface.h:5039
kRegShiftVidProcVancSource
@ kRegShiftVidProcVancSource
Definition: ntv2publicinterface.h:2435
NTV2DieTempScale_Fahrenheit
@ NTV2DieTempScale_Fahrenheit
Definition: ntv2enums.h:4198
CNTV2Card::Get64BitAutodetect
virtual bool Get64BitAutodetect(ULWord *autodetect64)
Definition: ntv2register.cpp:3252
kRegMRQ4Control
@ kRegMRQ4Control
Definition: ntv2publicinterface.h:1053
NTV2_INPUTSOURCE_HDMI2
@ NTV2_INPUTSOURCE_HDMI2
Identifies the 2nd HDMI video input.
Definition: ntv2enums.h:1262
NTV2_FORMAT_4x4096x2160p_6000
@ NTV2_FORMAT_4x4096x2160p_6000
Definition: ntv2enums.h:710
kRegMaskSDI3Transmit
@ kRegMaskSDI3Transmit
Definition: ntv2publicinterface.h:2092
NTV2_FORMAT_3840x2160p_2398
@ NTV2_FORMAT_3840x2160p_2398
Definition: ntv2enums.h:639
NTV2_FG_1920x1112
@ NTV2_FG_1920x1112
1920x1080, for 1080i and 1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:355
kRegSDIOut6Control
@ kRegSDIOut6Control
Definition: ntv2publicinterface.h:664
NTV2InputSource
NTV2InputSource
Identifies a specific video input source.
Definition: ntv2enums.h:1258
NTV2SDIInputStatus::mFrameRefClockCount
ULWord64 mFrameRefClockCount
This count is incremented on each 148.xx reference clock, and latched at EAV for each frame.
Definition: ntv2publicinterface.h:7115
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:4757
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:2925
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:530
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:3387
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:7111
NTV2_IS_QUAD_QUAD_FORMAT
#define NTV2_IS_QUAD_QUAD_FORMAT(__f__)
Definition: ntv2enums.h:815
kRegMROutControl
@ kRegMROutControl
Definition: ntv2publicinterface.h:1054
NTV2_FORMAT_4x1920x1080psf_2398
@ NTV2_FORMAT_4x1920x1080psf_2398
Definition: ntv2enums.h:590
kRegMaskInputStatusLock
@ kRegMaskInputStatusLock
Definition: ntv2publicinterface.h:1615
CNTV2Card::GetHDMIInputVideoFormat
virtual NTV2VideoFormat GetHDMIInputVideoFormat(NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Definition: ntv2register.cpp:3519
kRegShiftQuadQuadMode2
@ kRegShiftQuadQuadMode2
Definition: ntv2publicinterface.h:2379
NTV2_STANDARD_2K
@ NTV2_STANDARD_2K
Definition: ntv2enums.h:168
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:622
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:4443
NTV2_FG_720x598
@ NTV2_FG_720x598
720x576, for PAL 625i, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:354
NTV2_FBF_10BIT_YCBCR
@ NTV2_FBF_10BIT_YCBCR
See 10-Bit YCbCr Format.
Definition: ntv2enums.h:218
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:3258
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:4254
NTV2EncodeAsPSF
NTV2EncodeAsPSF
Definition: ntv2enums.h:2508
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:2114
CNTV2Card::GetDualLinkInputEnable
virtual bool GetDualLinkInputEnable(bool &outIsEnabled)
Definition: ntv2register.cpp:3225
kRegRP188InOut2Bits32_63
@ kRegRP188InOut2Bits32_63
Definition: ntv2publicinterface.h:187
CNTV2Card::GetDualLinkOutputEnable
virtual bool GetDualLinkOutputEnable(bool &outIsEnabled)
Definition: ntv2register.cpp:3212
CNTV2Card::SetMixerRGBRange
virtual bool SetMixerRGBRange(const UWord inWhichMixer, const NTV2MixerRGBRange inRGBRange)
Sets the RGB range for the given mixer/keyer.
Definition: ntv2register.cpp:3117
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:381
NTV2_RS422_EVEN_PARITY
@ NTV2_RS422_EVEN_PARITY
Even parity.
Definition: ntv2enums.h:4151
NTV2_FORMAT_4096x2160p_3000
@ NTV2_FORMAT_4096x2160p_3000
Definition: ntv2enums.h:661
kK2RegMaskSDIOutStandard
@ kK2RegMaskSDIOutStandard
Definition: ntv2publicinterface.h:1668
DEC
#define DEC(__x__)
Definition: ntv2publicinterface.h:5769
CNTV2Card::SetSDIOutputStandard
virtual bool SetSDIOutputStandard(const UWord inOutputSpigot, const NTV2Standard inValue)
Sets the SDI output spigot's video standard.
Definition: ntv2register.cpp:3263
kK2RegMaskSDIOutDS2AudioSelect
@ kK2RegMaskSDIOutDS2AudioSelect
Definition: ntv2publicinterface.h:1688
BIT_23
#define BIT_23
Definition: ajatypes.h:617
kRegShiftAutodetect64
@ kRegShiftAutodetect64
Definition: ntv2publicinterface.h:2528
NTV2VideoLimiting
NTV2VideoLimiting
These enum values identify the available SDI video output limiting modes.
Definition: ntv2enums.h:3763
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:592
NTV2SDIInStatistics
This is used by the CNTV2Card::ReadSDIStatistics function.
Definition: ntv2publicinterface.h:7967
NTV2_FRAMERATE_5994
@ NTV2_FRAMERATE_5994
Fractional rate of 60,000 frames per 1,001 seconds.
Definition: ntv2enums.h:413
kRegShiftFramePulseRefSelect
@ kRegShiftFramePulseRefSelect
Definition: ntv2publicinterface.h:2383
CNTV2Card::DisableChannels
virtual bool DisableChannels(const NTV2ChannelSet &inChannels)
Disables the given FrameStore(s).
Definition: ntv2register.cpp:2150
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:689
CNTV2Card::Enable4KPSFOutMode
virtual bool Enable4KPSFOutMode(bool inEnable)
Sets 4K Down Convert PSF out Mode.
Definition: ntv2register.cpp:4240
UByte
uint8_t UByte
Definition: ajatypes.h:271
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:165
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:3973
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:4679
kRegRXSDI2Status
@ kRegRXSDI2Status
Definition: ntv2publicinterface.h:729
NTV2_FRAMESIZE_26MB
@ NTV2_FRAMESIZE_26MB
Definition: ntv2enums.h:2126
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:2916
kRegMaskInput1Progressive
@ kRegMaskInput1Progressive
Definition: ntv2publicinterface.h:1414
CNTV2Card::GetCRCErrorCountA
virtual ULWord GetCRCErrorCountA(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4287
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:1947
ntv2konaflashprogram.h
Declares the CNTV2KonaFlashProgram class.
NTV2_FORMAT_4x2048x1080p_2500
@ NTV2_FORMAT_4x2048x1080p_2500
Definition: ntv2enums.h:601
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:7044
NTV2_FORMAT_4x1920x1080p_5994
@ NTV2_FORMAT_4x1920x1080p_5994
Definition: ntv2enums.h:611
NTV2_FORMAT_720p_2398
@ NTV2_FORMAT_720p_2398
Definition: ntv2enums.h:563
NTV2_FORMAT_4x4096x2160p_5000
@ NTV2_FORMAT_4x4096x2160p_5000
Definition: ntv2enums.h:708
NTV2FrameBufferFormatToString
std::string NTV2FrameBufferFormatToString(const NTV2FrameBufferFormat inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:6925
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:1675
CNTV2Card::GetBaseAddress
virtual bool GetBaseAddress(NTV2Channel channel, ULWord **pBaseAddress)
Definition: ntv2register.cpp:3140
CNTV2Card::GetAnalogOutHTiming
virtual bool GetAnalogOutHTiming(ULWord &outValue)
Definition: ntv2register.cpp:3261
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:1272
NTV2_FORMAT_4x3840x2160p_6000
@ NTV2_FORMAT_4x3840x2160p_6000
Definition: ntv2enums.h:695
kRegRXSDI3Status
@ kRegRXSDI3Status
Definition: ntv2publicinterface.h:738
NTV2_IS_VALID_VIDEOLIMITING
#define NTV2_IS_VALID_VIDEOLIMITING(__v__)
Definition: ntv2enums.h:3772
kRegMaskRefSource
@ kRegMaskRefSource
Definition: ntv2publicinterface.h:1239
NTV2_STANDARD_3840HFR
@ NTV2_STANDARD_3840HFR
Identifies high frame-rate UHD.
Definition: ntv2enums.h:173
NTV2_FRAMESIZE_14MB
@ NTV2_FRAMESIZE_14MB
Definition: ntv2enums.h:2121
gChannelToControlRegNum
static const ULWord gChannelToControlRegNum[]
Definition: ntv2register.cpp:74
NTV2_FRAMESIZE_8MB
@ NTV2_FRAMESIZE_8MB
Definition: ntv2enums.h:2116
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:2320
kRegCh8Control2MFrame
@ kRegCh8Control2MFrame
Definition: ntv2publicinterface.h:701
ULWord64
uint64_t ULWord64
Definition: ajatypes.h:279
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:4341
NTV2_INPUTSOURCE_SDI2
@ NTV2_INPUTSOURCE_SDI2
Identifies the 2nd SDI video input.
Definition: ntv2enums.h:1266
NTV2_FRAMESIZE_6MB
@ NTV2_FRAMESIZE_6MB
Definition: ntv2enums.h:2118
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:7002
CNTV2Card::SetLTCEmbeddedOutEnable
virtual bool SetLTCEmbeddedOutEnable(const bool inNewValue)
Definition: ntv2register.cpp:3747
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:2983
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:170
NTV2_FRAMERATE_UNKNOWN
@ NTV2_FRAMERATE_UNKNOWN
Represents an unknown or invalid frame rate.
Definition: ntv2enums.h:410
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:2213
NTV2_RS422_BAUD_RATE_38400
@ NTV2_RS422_BAUD_RATE_38400
38400 baud – this is the power-up default
Definition: ntv2enums.h:4164
kRegMaskSDIWatchdogStatus
@ kRegMaskSDIWatchdogStatus
Definition: ntv2publicinterface.h:2102
NTV2_FORMAT_1080p_5000_A
@ NTV2_FORMAT_1080p_5000_A
Definition: ntv2enums.h:565
NTV2FrameBufferQuality
NTV2FrameBufferQuality
Definition: ntv2enums.h:2493
NTV2_FORMAT_4x2048x1080p_6000
@ NTV2_FORMAT_4x2048x1080p_6000
Definition: ntv2enums.h:615
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:4167
NTV2_FORMAT_3840x2160psf_2997
@ NTV2_FORMAT_3840x2160psf_2997
Definition: ntv2enums.h:644
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:176
gMatteColorRegs
static const ULWord gMatteColorRegs[]
Definition: ntv2register.cpp:3067
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:4148
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:666
NTV2_FRAMESIZE_22MB
@ NTV2_FRAMESIZE_22MB
Definition: ntv2enums.h:2124
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:4494
kRegShiftSDIIn2LevelBtoLevelA
@ kRegShiftSDIIn2LevelBtoLevelA
Definition: ntv2publicinterface.h:3049
kRegCh7InputFrame
@ kRegCh7InputFrame
Definition: ntv2publicinterface.h:565
NTV2_FORMAT_1080i_5000
@ NTV2_FORMAT_1080i_5000
Definition: ntv2enums.h:543
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:3934
kRegMaskFrameRate
@ kRegMaskFrameRate
Definition: ntv2publicinterface.h:1235
kRegCh1ControlExtended
@ kRegCh1ControlExtended
Definition: ntv2publicinterface.h:303
CNTV2Card::SetMultiRasterBypassEnable
virtual bool SetMultiRasterBypassEnable(const bool inEnable)
Definition: ntv2register.cpp:4752
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:610
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:3923
AJA_FALL_THRU
#define AJA_FALL_THRU
Definition: ajatypes.h:240
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:164
kRegCh6PCIAccessFrame
@ kRegCh6PCIAccessFrame
Definition: ntv2publicinterface.h:561
NTV2_RS422_NO_PARITY
@ NTV2_RS422_NO_PARITY
No parity.
Definition: ntv2enums.h:4149
NTV2_FORMAT_4x1920x1080p_2398
@ NTV2_FORMAT_4x1920x1080p_2398
Definition: ntv2enums.h:593
NTV2_FG_2048x1112
@ NTV2_FG_2048x1112
2048x1080, for 2Kx1080p, NTV2_VANCMODE_TALL
Definition: ntv2enums.h:360
kRegMaskSDIIn73GbpsMode
@ kRegMaskSDIIn73GbpsMode
Definition: ntv2publicinterface.h:2023
CNTV2Card::AbortMailBoxLock
virtual bool AbortMailBoxLock(void)
Definition: ntv2register.cpp:4551
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:4699
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:4066
NTV2FrameGeometry
NTV2FrameGeometry
Identifies a particular video frame geometry.
Definition: ntv2enums.h:344
CNTV2Card::IsChannelEnabled
virtual bool IsChannelEnabled(const NTV2Channel inChannel, bool &outEnabled)
Answers whether or not the given FrameStore is enabled.
Definition: ntv2register.cpp:2185
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:5046
NTV2_FORMAT_1080p_6000_B
@ NTV2_FORMAT_1080p_6000_B
Definition: ntv2enums.h:562
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:3804
CNTV2DriverInterface::GetFrameBufferSize
virtual ULWord GetFrameBufferSize(void) const
Definition: ntv2driverinterface.h:379
kRegMaskRP188ModeCh3
@ kRegMaskRP188ModeCh3
Definition: ntv2publicinterface.h:1276
GetQuadSizedVideoFormat
NTV2VideoFormat GetQuadSizedVideoFormat(const NTV2VideoFormat inVideoFormat, const bool isSquareDivision=true)
Definition: ntv2utils.cpp:2129
kRegCh8PCIAccessFrame
@ kRegCh8PCIAccessFrame
Definition: ntv2publicinterface.h:571
NTV2_FORMAT_4096x2160p_2997
@ NTV2_FORMAT_4096x2160p_2997
Definition: ntv2enums.h:660
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:3124
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:3415
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:7809
kRegShiftSDIIn4LevelBtoLevelA
@ kRegShiftSDIIn4LevelBtoLevelA
Definition: ntv2publicinterface.h:3066
NTV2_IS_QUAD_FRAME_FORMAT
#define NTV2_IS_QUAD_FRAME_FORMAT(__f__)
Definition: ntv2enums.h:808
kRegCh1Control
@ kRegCh1Control
Definition: ntv2publicinterface.h:121
kRegMRQ2Control
@ kRegMRQ2Control
Definition: ntv2publicinterface.h:1051
CNTV2Card::IsMultiRasterWidgetChannel
virtual bool IsMultiRasterWidgetChannel(const NTV2Channel inChannel)
Definition: ntv2register.cpp:4776
NTV2_FORMAT_1080p_5994_A
@ NTV2_FORMAT_1080p_5994_A
Definition: ntv2enums.h:566
NTV2_FG_2048x1114
@ NTV2_FG_2048x1114
2048x1080, NTV2_VANCMODE_TALLER
Definition: ntv2enums.h:352
NTV2VideoLimitingToString
std::string NTV2VideoLimitingToString(const NTV2VideoLimiting inValue, const bool inCompactDisplay=false)
Definition: ntv2utils.cpp:6534
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:3037
NTV2SetRegisters::mOutNumFailures
ULWord mOutNumFailures
The number of registers unsuccessfully written.
Definition: ntv2publicinterface.h:7813
NTV2_IS_VALID_NTV2FrameRate
#define NTV2_IS_VALID_NTV2FrameRate(__r__)
Definition: ntv2enums.h:440
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:2357
CNTV2Card::GetPCIDeviceID
virtual bool GetPCIDeviceID(ULWord &outPCIDeviceID)
Answers with my PCI device ID.
Definition: ntv2register.cpp:2466
gChlToRP188Bits031RegNum
static const ULWord gChlToRP188Bits031RegNum[]
Definition: ntv2register.cpp:117
NTV2_FORMAT_4x2048x1080p_5994
@ NTV2_FORMAT_4x2048x1080p_5994
Definition: ntv2enums.h:614
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:2272
NTV2WidgetType_SDIIn3G
@ NTV2WidgetType_SDIIn3G
Definition: ntv2enums.h:3042
NTV2_FBQualityInvalid
@ NTV2_FBQualityInvalid
Definition: ntv2enums.h:2502
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:2783
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:1828
NTV2_FG_4x1920x1080
@ NTV2_FG_4x1920x1080
3840x2160, for UHD, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:363
NTV2VANCDataShiftMode
NTV2VANCDataShiftMode
Definition: ntv2enums.h:3798
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:2612
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:2625
NTV2HDRLuminance
enum NTV2VPIDLuminance NTV2HDRLuminance
NTV2_FORMAT_4x3840x2160p_3000
@ NTV2_FORMAT_4x3840x2160p_3000
Definition: ntv2enums.h:692
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:7926
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:7109
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:3791
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:2375
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:2334
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:7119
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:4195
kRegShift2MFrameSupport
@ kRegShift2MFrameSupport
Definition: ntv2publicinterface.h:2362
NTV2_FORMAT_3840x2160p_5000
@ NTV2_FORMAT_3840x2160p_5000
Definition: ntv2enums.h:646
kRegSDITransmitControl
@ kRegSDITransmitControl
Definition: ntv2publicinterface.h:397
CNTV2Card::SetAnalogOutHTiming
virtual bool SetAnalogOutHTiming(ULWord inValue)
Definition: ntv2register.cpp:3260
NTV2_FORMAT_720p_5994
@ NTV2_FORMAT_720p_5994
Definition: ntv2enums.h:546
NTV2_FORMAT_4096x2160psf_3000
@ NTV2_FORMAT_4096x2160psf_3000
Definition: ntv2enums.h:663
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:356
CNTV2Card::GetDitherFor8BitInputs
virtual bool GetDitherFor8BitInputs(const NTV2Channel inChannel, ULWord &outDither)
Definition: ntv2register.cpp:3241
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:626
NTV2_FRAMERATE_5000
@ NTV2_FRAMERATE_5000
50 frames per second
Definition: ntv2enums.h:419
CNTV2Card::GetNumberActiveLines
virtual bool GetNumberActiveLines(ULWord &outNumActiveLines)
Definition: ntv2register.cpp:772
CNTV2Card::GetSDIInputIsProgressive
virtual bool GetSDIInputIsProgressive(const NTV2Channel channel)
Definition: ntv2register.cpp:3655
kRegShiftMode
@ kRegShiftMode
Definition: ntv2publicinterface.h:2396
NTV2MixerRGBRange
NTV2MixerRGBRange
Definition: ntv2enums.h:2270
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:3722
kRegMask4KDCRGBMode
@ kRegMask4KDCRGBMode
Definition: ntv2publicinterface.h:2105
kRegCh5Control
@ kRegCh5Control
Definition: ntv2publicinterface.h:553
NTV2_FORMAT_4x2048x1080psf_2500
@ NTV2_FORMAT_4x2048x1080psf_2500
Definition: ntv2enums.h:598
YCbCr10BitPixel::y
UWord y
Definition: ntv2videodefines.h:203
NTV2_INPUTSOURCE_SDI3
@ NTV2_INPUTSOURCE_SDI3
Identifies the 3rd SDI video input.
Definition: ntv2enums.h:1267
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:4516
kRegShiftQuadMode2
@ kRegShiftQuadMode2
Definition: ntv2publicinterface.h:2357
NTV2OutputCrosspointIDToString
std::string NTV2OutputCrosspointIDToString(const NTV2OutputCrosspointID inValue, const bool inForRetailDisplay=false)
Definition: ntv2utils.cpp:5954
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:358
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:2562
kRegCh6InputFrame
@ kRegCh6InputFrame
Definition: ntv2publicinterface.h:560
NTV2_REFERENCE_EXTERNAL
@ NTV2_REFERENCE_EXTERNAL
Specifies the External Reference connector.
Definition: ntv2enums.h:1452
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:421
NTV2_FORMAT_2K_1500
@ NTV2_FORMAT_2K_1500
Definition: ntv2enums.h:584
NTV2_IS_TSI_FORMAT
#define NTV2_IS_TSI_FORMAT(__f__)
Definition: ntv2enums.h:1188
kRegShiftRP188ModeCh5
@ kRegShiftRP188ModeCh5
Definition: ntv2publicinterface.h:2371
CNTV2Card::SetPulldownMode
virtual bool SetPulldownMode(NTV2Channel inChannel, bool inValue)
Definition: ntv2register.cpp:2894
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:414
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:4104
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:3449
kRegLTC2AnalogBits0_31
@ kRegLTC2AnalogBits0_31
Definition: ntv2publicinterface.h:395
NTV2_FRAMESIZE_16MB
@ NTV2_FRAMESIZE_16MB
Definition: ntv2enums.h:2117
BIT
#define BIT(_x_)
Definition: ajatypes.h:585
sSDIXmitEnableMasks
static const ULWord sSDIXmitEnableMasks[]
Definition: ntv2register.cpp:3854
xHEX0N
#define xHEX0N(__x__, __n__)
Definition: ntv2publicinterface.h:5768
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:4415
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:3880
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:578
CNTV2Card::SetDualLinkOutputEnable
virtual bool SetDualLinkOutputEnable(const bool inIsEnabled)
Definition: ntv2register.cpp:3207
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:2363
NTV2_FG_4x3840x2160
@ NTV2_FG_4x3840x2160
7680x4320, for UHD2, NTV2_VANCMODE_OFF
Definition: ntv2enums.h:367
CNTV2Card::SetAlphaFromInput2Bit
virtual bool SetAlphaFromInput2Bit(ULWord inValue)
Definition: ntv2register.cpp:2290
kRegShiftSDIIn63GbpsMode
@ kRegShiftSDIIn63GbpsMode
Definition: ntv2publicinterface.h:3080
NTV2_FORMAT_1080psf_2997_2
@ NTV2_FORMAT_1080psf_2997_2
Definition: ntv2enums.h:571
NTV2_RS422_PARITY_INVALID
@ NTV2_RS422_PARITY_INVALID
Definition: ntv2enums.h:4152
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:1463
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:2199
NTV2_IS_VALID_VANCMODE
#define NTV2_IS_VALID_VANCMODE(__v__)
Definition: ntv2enums.h:3790
NTV2_FORMAT_4x4096x2160p_5994
@ NTV2_FORMAT_4x4096x2160p_5994
Definition: ntv2enums.h:709
NTV2_FORMAT_4x2048x1080p_2400
@ NTV2_FORMAT_4x2048x1080p_2400
Definition: ntv2enums.h:600
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:2511
kRegLTCStatusControl
@ kRegLTCStatusControl
Definition: ntv2publicinterface.h:374
kRegCh8InputFrame
@ kRegCh8InputFrame
Definition: ntv2publicinterface.h:570
NTV2MixerKeyerMode
NTV2MixerKeyerMode
These enum values identify the mixer mode.
Definition: ntv2enums.h:1787
CNTV2Card::EnableChannel
virtual bool EnableChannel(const NTV2Channel inChannel)
Enables the given FrameStore.
Definition: ntv2register.cpp:2160
NTV2_FRAMESIZE_INVALID
@ NTV2_FRAMESIZE_INVALID
Definition: ntv2enums.h:2131
CNTV2Card::GetSDIInputGeometry
virtual NTV2FrameGeometry GetSDIInputGeometry(const NTV2Channel channel)
Definition: ntv2register.cpp:3638
NTV2_FORMAT_1080p_2K_4800_B
@ NTV2_FORMAT_1080p_2K_4800_B
Definition: ntv2enums.h:630
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:1469
CNTV2VPID::IsStandardMultiLink4320
virtual bool IsStandardMultiLink4320(void) const
Definition: ntv2vpid.cpp:266
NTV2_STANDARD_7680
@ NTV2_STANDARD_7680
Identifies UHD2.
Definition: ntv2enums.h:175
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:594
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:591
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:346
AJAFUNC
#define AJAFUNC
Definition: ajatypes.h:346
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:454
gChannelToRS422ControlRegNum
static const ULWord gChannelToRS422ControlRegNum[]
Definition: ntv2register.cpp:86
NTV2_FRAMESIZE_24MB
@ NTV2_FRAMESIZE_24MB
Definition: ntv2enums.h:2125
NTV2_RS422_BAUD_RATE
NTV2_RS422_BAUD_RATE
These enum values identify RS-422 serial port baud rate configuration.
Definition: ntv2enums.h:4162
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:570
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:1991
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:4706
kVRegMailBoxRelease
@ kVRegMailBoxRelease
Definition: ntv2virtualregisters.h:414
NTV2_FORMAT_3840x2160p_2400
@ NTV2_FORMAT_3840x2160p_2400
Definition: ntv2enums.h:640
NTV2_FORMAT_1080p_2400
@ NTV2_FORMAT_1080p_2400
Definition: ntv2enums.h:554
NTV2_FORMAT_1080i_6000
@ NTV2_FORMAT_1080i_6000
Definition: ntv2enums.h:545
CNTV2Card::GetSDIInput3GbPresent
virtual bool GetSDIInput3GbPresent(bool &outValue, const NTV2Channel channel)
Definition: ntv2register.cpp:3677
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:3016
kRegShiftSDIIn83GbpsMode
@ kRegShiftSDIIn83GbpsMode
Definition: ntv2publicinterface.h:3094
CNTV2Card::GetTransmitSDIs
virtual bool GetTransmitSDIs(NTV2ChannelSet &outXmitSDIs)
Answers with the transmitting/output SDI connectors.
Definition: ntv2register.cpp:3892
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:4364
NTV2_STANDARD_3840i
@ NTV2_STANDARD_3840i
Identifies Ultra-High-Definition (UHD) psf.
Definition: ntv2enums.h:177
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:4668
debug.h
Declares the AJADebug class.
kRegShiftRP188ModeCh6
@ kRegShiftRP188ModeCh6
Definition: ntv2publicinterface.h:2372
NTV2_FORMAT_3840x2160p_3000
@ NTV2_FORMAT_3840x2160p_3000
Definition: ntv2enums.h:643
kRegMaskSDIIn66GbpsMode
@ kRegMaskSDIIn66GbpsMode
Definition: ntv2publicinterface.h:2021
kRegShiftSDIInCRCErrorCountA
@ kRegShiftSDIInCRCErrorCountA
Definition: ntv2publicinterface.h:3184
NTV2_FORMAT_1080psf_2400
@ NTV2_FORMAT_1080psf_2400
Definition: ntv2enums.h:549
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:185
kRegRP188InOut6DBB
@ kRegRP188InOut6DBB
Definition: ntv2publicinterface.h:593
kRegMaskSDIIn6LevelBtoLevelA
@ kRegMaskSDIIn6LevelBtoLevelA
Definition: ntv2publicinterface.h:2018
CNTV2Card::GetAlphaFromInput2Bit
virtual bool GetAlphaFromInput2Bit(ULWord &outValue)
Definition: ntv2register.cpp:2291
NTV2_FORMAT_4096x2160p_5994
@ NTV2_FORMAT_4096x2160p_5994
Definition: ntv2enums.h:667
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:2293
NTV2_RP188Mode
NTV2_RP188Mode
Definition: ntv2enums.h:2091
kDeviceGetNumLTCInputs
@ kDeviceGetNumLTCInputs
The number of analog LTC inputs on the device.
Definition: ntv2devicefeatures.h:216
NTV2InputVideoSelect
NTV2InputVideoSelect
Definition: ntv2enums.h:2292
NTV2_REFERENCE_SFP1_PCR
@ NTV2_REFERENCE_SFP1_PCR
Specifies the PCR source on SFP 1.
Definition: ntv2enums.h:1465
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:2023
kRegGlobalControl
@ kRegGlobalControl
Definition: ntv2publicinterface.h:120
kRegMaskRS422ParitySense
@ kRegMaskRS422ParitySense
Definition: ntv2publicinterface.h:1497
NTV2VideoDACMode
NTV2VideoDACMode
Definition: ntv2enums.h:2138
NTV2_FORMAT_4x2048x1080psf_2997
@ NTV2_FORMAT_4x2048x1080psf_2997
Definition: ntv2enums.h:608
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:3766
kRegMaskSDIIn83GbpsSMPTELevelBMode
@ kRegMaskSDIIn83GbpsSMPTELevelBMode
Definition: ntv2publicinterface.h:2031
NTV2_AUDIOSYSTEM_INVALID
@ NTV2_AUDIOSYSTEM_INVALID
Definition: ntv2enums.h:3892
NTV2_FORMAT_1080p_2K_2997
@ NTV2_FORMAT_1080p_2K_2997
Definition: ntv2enums.h:624
kRegShiftFrameOrientation
@ kRegShiftFrameOrientation
Definition: ntv2publicinterface.h:2402
CNTV2Card::GetFrameBufferQuality
virtual bool GetFrameBufferQuality(NTV2Channel inChannel, NTV2FrameBufferQuality &outValue)
Definition: ntv2register.cpp:1971
gChannelToRP188ModeGCRegisterNum
static const ULWord gChannelToRP188ModeGCRegisterNum[]
Definition: ntv2register.cpp:109