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