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