AJA NTV2 SDK  18.0.0.2122
NTV2 SDK 18.0.0.2122
ntv2aux.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: MIT */
8 //==========================================================================
9 //
10 // HDMI Aux Insertion is not yet implemented. The functions here are copied from
11 // Ans Insertion to be used as a potential template.
12 //
13 //==========================================================================
14 
15 
16 #include "ntv2card.h"
17 #include "ntv2devicefeatures.h"
18 #include "ntv2formatdescriptor.h"
19 #include "ntv2utils.h"
20 
21 
25 
26 // HDMI PORT: 1 2 3 4
27 // CURRENTLY UNUSED // static const ULWord sAuxInsBaseRegNum[] = { 4608, 4672, 4736, 4800 };
28 static const ULWord sAuxExtBaseRegNum[] = { 7616, 7680, 7744, 7808 };
29 static const ULWord kNumDIDRegisters (regAuxExtPacketMask_Last - regAuxExtPacketMask_First + 1);
30 
31 // AUXInsRegisters not yet defined
32 // static inline ULWord AuxInsRegNum(const UWord inSDIOutput, const AUXInsRegisters inReg)
33 // {
34 // return sAuxInsBaseRegNum[inSDIOutput] + inReg;
35 // }
36 
37 static inline ULWord AuxExtRegNum(const UWord inHDMIInput, const AUXExtRegisters inReg)
38 {
39  return sAuxExtBaseRegNum[inHDMIInput] + inReg;
40 }
41 
45 
46 // CURRENTLY UNUSED //
47 // typedef struct AUXInserterInitParams
48 // {
49 // uint32_t field1ActiveLine;
50 // uint32_t field2ActiveLine;
51 // uint32_t hActivePixels;
52 // uint32_t hTotalPixels;
53 // uint32_t totalLines;
54 // uint32_t fidLow;
55 // uint32_t fidHigh;
56 // uint32_t field1SwitchLine;
57 // uint32_t field2SwitchLine;
58 // uint32_t pixelDelay;
59 // } AUXInserterInitParams;
60 
61 // CURRENTLY UNUSED //
62 
63 // static const AUXInserterInitParams inserterInitParamsTable [NTV2_NUM_STANDARDS] = {
64 // // F1 F2 Horz F1 F2
65 // // Active Active Active Total Total FID FID Switch Switch Pixel
66 // // Standard Line Line Pixels Pixels Lines Lo Hi Line Line Delay
67 // /* 1080 */ { 21, 564, 1920, 2200, 1125, 1125, 563, 7, 569, 8, },
68 // /* 720 */ { 26, 0, 1280, 1280, 750, 0, 0, 7, 0, 8, },
69 // /* 525 */ { 21, 283, 720, 720, 525, 3, 265, 10, 273, 8, },
70 // /* 625 */ { 23, 336, 720, 864, 625, 625, 312, 6, 319, 8, },
71 // /* 1080p */ { 42, 0, 1920, 2640, 1125, 0, 0, 7, 0, 8, },
72 // /* 2K */ { 42, 0, 2048, 2640, 1125, 0, 0, 7, 0, 8, },
73 // /* 2Kx1080p */ { 42, 0, 2048, 2640, 1125, 0, 0, 7, 0, 8, },
74 // /* 2Kx1080i */ { 21, 564, 2048, 2200, 1125, 1125, 563, 7, 569, 8, },
75 // /* 3840x2160p */ { 42, 0, 1920, 2640, 1125, 0, 0, 7, 0, 8, },
76 // /* 4096x2160p */ { 42, 0, 2048, 2640, 1125, 0, 0, 7, 0, 8, },
77 // /* 3840HFR */ { 42, 0, 1920, 2640, 1125, 0, 0, 7, 0, 8, },
78 // /* 4096HFR */ { 42, 0, 2048, 2640, 1125, 0, 0, 7, 0, 8, }
79 // };
80 
81 
82 
86 
87 typedef struct AUXExtractorInitParams
88 {
89  uint32_t field1StartLine;
90  uint32_t field1CutoffLine;
91  uint32_t field2StartLine;
92  uint32_t field2CutoffLine;
93  uint32_t totalLines;
94  uint32_t fidLow;
95  uint32_t fidHigh;
96  uint32_t field1SwitchLine;
97  uint32_t field2SwitchLine;
98  uint32_t field1AnalogStartLine;
99  uint32_t field2AnalogStartLine;
100  uint32_t field1AnalogYFilter;
101  uint32_t field2AnalogYFilter;
102  uint32_t field1AnalogCFilter;
103  uint32_t field2AnalogCFilter;
104  uint32_t analogActiveLineLength;
105 } AUXExtractorInitParams;
106 
107 const static AUXExtractorInitParams extractorInitParamsTable [NTV2_NUM_STANDARDS] = {
108 // F1 F1 F2 F2 F1 F2 F1Anlg F2Anlg F1 F2 F1 F2 Analog
109 // Start Cutoff Start Cutoff Total FID FID Switch Switch Start Start Anlg Anlg Anlg Anlg Active
110 // Standard Line Line Line Line Lines Low High Line Line Line Line Y Filt Y Filt C Filt C Filt LineLength
111 /* 1080 */{ 561, 26, 1124, 588, 1125, 1125, 563, 7, 569, 0, 0, 0, 0, 0, 0, 0x07800000 },
112 /* 720 */{ 746, 745, 0, 0, 750, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x05000000 },
113 /* 525 */{ 264, 30, 1, 293, 525, 3, 265, 10, 273, 4, 266, 0x20000, 0x40000, 0, 0, 0x02D00000 },
114 /* 625 */{ 311, 33, 1, 346, 625, 625, 312, 6, 319, 5, 318, 0x10000, 0x10000, 0, 0, 0x02D00000 },
115 /* 1080p */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
116 /* 2K */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
117 /* 2Kx1080p */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
118 /* 2Kx1080i */{ 561, 26, 1124, 588, 1125, 1125, 563, 7, 569, 0, 0, 0, 0, 0, 0, 0x07800000 },
119 /* 3840x2160p */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
120 /* 4096x2160p */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
121 /* 3840HFR */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
122 /* 4096HFR */{ 1122, 1125, 0, 0, 1125, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0x07800000 },
123 };
124 
125 
129 
130 // As of now, Aux buffers share the same virtual registers than Anc uses:
131 // kVRegAncField1Offset & kVRegAncField2Offset
132 // To reduce user confusion, we created AuxSetFrameBufferSize, but it simply calls AncSetFrameBufferSize,
133 // which sets these two registers.
134 
135 static bool GetAuxOffsets (CNTV2Card & inDevice, ULWord & outF1Offset, ULWord & outF2Offset)
136 {
137  outF1Offset = outF2Offset = 0;
138  return inDevice.ReadRegister(kVRegAncField1Offset, outF1Offset)
139  && inDevice.ReadRegister(kVRegAncField2Offset, outF2Offset);
140 }
141 
142 // static bool GetAuxField1Size (CNTV2Card & inDevice, ULWord & outFieldBytes)
143 // {
144  // outFieldBytes = 0;
145  // ULWord auxF1Offset(0), auxF2Offset(0);
146  // if (!GetAuxOffsets(inDevice, auxF1Offset, auxF2Offset))
147  // return false;
148  // outFieldBytes = auxF1Offset - auxF2Offset;
149  // return true;
150 // }
151 
152 // static bool GetAuxField2Size (CNTV2Card & inDevice, ULWord & outFieldBytes)
153 // {
154  // outFieldBytes = 0;
155  // ULWord auxF1Offset(0), auxF2Offset(0);
156  // if (!GetAuxOffsets(inDevice, auxF1Offset, auxF2Offset))
157  // return false;
158  // outFieldBytes = auxF2Offset;
159  // return true;
160 // }
161 
162 
166 
167 // static bool SetAuxInsField1Bytes (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfBytes)
168 // {
169  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldBytes), numberOfBytes & 0xffff,
170  // maskInsField1Bytes, shiftInsField1Bytes) &&
171  // inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldBytesHigh), numberOfBytes >> 16,
172  // maskInsField1Bytes, shiftInsField1Bytes);
173 // }
174 
175 // static bool SetAuxInsField2Bytes (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfBytes)
176 // {
177  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldBytes), numberOfBytes & 0xffff,
178  // maskInsField2Bytes, shiftInsField2Bytes) &&
179  // inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldBytesHigh), numberOfBytes >> 16,
180  // maskInsField2Bytes, shiftInsField2Bytes);
181 // }
182 
183 // static bool EnableAuxInsHauxY (CNTV2Card & inDevice, const UWord inSDIOutput, bool bEnable)
184 // {
185  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), bEnable ? 1 : 0, maskInsEnableHauxY, shiftInsEnableHauxY);
186 // }
187 
188 // static bool EnableAuxInsHauxC (CNTV2Card & inDevice, const UWord inSDIOutput, bool bEnable)
189 // {
190  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), bEnable ? 1 : 0, maskInsEnableHauxC, shiftInsEnableHauxC);
191 // }
192 
193 // static bool EnableAuxInsVauxY (CNTV2Card & inDevice, const UWord inSDIOutput, bool bEnable)
194 // {
195  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), bEnable ? 1 : 0, maskInsEnableVauxY, shiftInsEnableVauxY);
196 // }
197 
198 // static bool EnableAuxInsVauxC (CNTV2Card & inDevice, const UWord inSDIOutput, bool bEnable)
199 // {
200  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), bEnable ? 1 : 0, maskInsEnableVauxC, shiftInsEnableVauxC);
201 // }
202 
203 // static bool SetAuxInsProgressive (CNTV2Card & inDevice, const UWord inSDIOutput, bool isProgressive)
204 // {
205  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), isProgressive ? 1 : 0, maskInsSetProgressive, shiftInsSetProgressive);
206 // }
207 
208 // static bool SetAuxInsSDPacketSplit (CNTV2Card & inDevice, const UWord inSDIOutput, bool inEnable)
209 // {
210  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), inEnable ? 1 : 0, ULWord(maskInsEnablePktSplitSD), shiftInsEnablePktSplitSD);
211 // }
212 
213 // static bool GetAuxInsStartAddrs (CNTV2Card & inDevice, const UWord inSDIOutput, uint64_t & outStartAddrF1, uint64_t & outStartAddrF2)
214 // {
215  // uint32_t startAddrF1(0), startAddrF2(0);
216  // bool ok = inDevice.ReadRegister(AuxInsRegNum(inSDIOutput, regAuxInsField1StartAddr), startAddrF1)
217  // && inDevice.ReadRegister(AuxInsRegNum(inSDIOutput, regAuxInsField2StartAddr), startAddrF2);
218  // outStartAddrF1 = ok ? uint64_t(startAddrF1) : 0;
219  // outStartAddrF2 = ok ? uint64_t(startAddrF2) : 0;
220  // return ok;
221 // }
222 
223 // static bool SetAuxInsField1StartAddr (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t startAddr)
224 // {
225  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsField1StartAddr), startAddr);
226 // }
227 
228 // static bool SetAuxInsField2StartAddr (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t startAddr)
229 // {
230  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsField2StartAddr), startAddr);
231 // }
232 
233 // static bool SetAuxInsHauxPixelDelay (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfPixels)
234 // {
235  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsPixelDelay), numberOfPixels, maskInsHauxDelay, shiftINsHauxDelay);
236 // }
237 
238 // static bool SetAuxInsVauxPixelDelay (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfPixels)
239 // {
240  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsPixelDelay), numberOfPixels, maskInsVauxDelay, shiftInsVauxDelay);
241 // }
242 
243 // static bool SetAuxInsField1ActiveLine (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t activeLineNumber)
244 // {
245  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsActiveStart), activeLineNumber, maskInsField1FirstActive, shiftInsField1FirstActive);
246 // }
247 
248 // static bool SetAuxInsField2ActiveLine (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t activeLineNumber)
249 // {
250  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsActiveStart), activeLineNumber, maskInsField2FirstActive, shiftInsField2FirstActive);
251 // }
252 
253 // static bool SetAuxInsHActivePixels (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfActiveLinePixels)
254 // {
255  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsLinePixels), numberOfActiveLinePixels, maskInsActivePixelsInLine, shiftInsActivePixelsInLine);
256 // }
257 
258 // static bool SetAuxInsHTotalPixels (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfLinePixels)
259 // {
260  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsLinePixels), numberOfLinePixels, maskInsTotalPixelsInLine, shiftInsTotalPixelsInLine);
261 // }
262 
263 // static bool SetAuxInsTotalLines (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t numberOfLines)
264 // {
265  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFrameLines), numberOfLines, maskInsTotalLinesPerFrame, shiftInsTotalLinesPerFrame);
266 // }
267 
268 // static bool SetAuxInsFidHi (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t lineNumber)
269 // {
270  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldIDLines), lineNumber, maskInsFieldIDHigh, shiftInsFieldIDHigh);
271 // }
272 
273 // static bool SetAuxInsFidLow (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t lineNumber)
274 // {
275  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsFieldIDLines), lineNumber, maskInsFieldIDLow, shiftInsFieldIDLow);
276 // }
277 
278 // static bool SetAuxInsRtpPayloadID (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t payloadID)
279 // {
280  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsRtpPayloadID), payloadID);
281 // }
282 
283 // static bool SetAuxInsRtpSSRC (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t ssrc)
284 // {
285  // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsRtpSSRC), ssrc);
286 // }
287 
288 // static bool SetAuxInsIPChannel (CNTV2Card & inDevice, const UWord inSDIOutput, uint32_t channel)
289 // {
290 // return inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsIpChannel), channel);
291 // }
292 
293 // static bool GetAuxInsExtendedMode (CNTV2Card & inDevice, const UWord inSDIOutput, bool& extendedMode)
294 // {
295  // bool ok(true);
296  // uint32_t regValue(0);
297  // extendedMode = false;
298  // if (ok) ok = inDevice.WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), 1, maskInsExtendedMode, shiftInsExtendedMode);
299  // if (ok) ok = inDevice.ReadRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), regValue, maskInsExtendedMode, shiftInsExtendedMode);
300  // if (ok) extendedMode = (regValue == 1);
301  // return ok;
302 // }
303 
304 bool CNTV2Card::AuxInsertInit (const UWord inSDIOutput, const NTV2Channel inChannel, const NTV2Standard inStandard)
305 {
306  NTV2_UNUSED(inSDIOutput);
307  NTV2_UNUSED(inChannel);
308  NTV2_UNUSED(inStandard);
309  // if (!IsSupported(kDeviceCanDoPlayback))
310  // return false;
311  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
312  // return false;
313  // if (IS_OUTPUT_SPIGOT_INVALID(inSDIOutput))
314  // return false;
315 
316  // NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inSDIOutput));
317  // NTV2Standard theStandard (inStandard);
318  // if (!NTV2_IS_VALID_STANDARD(theStandard))
319  // {
320  // if (IS_CHANNEL_INVALID(theChannel))
321  // return false;
322  // if (!GetStandard(theStandard, theChannel))
323  // return false;
324  // if (!NTV2_IS_VALID_STANDARD(theStandard))
325  // return false;
326  // }
327 
328  // const AUXInserterInitParams & initParams(inserterInitParamsTable[theStandard]);
329  // bool ok(true);
330  // bool extendedMode(false);
331  // if (ok) ok = GetAuxInsExtendedMode (*this, inSDIOutput, extendedMode);
332  // if (ok) ok = SetAuxInsField1ActiveLine (*this, inSDIOutput, initParams.field1ActiveLine);
333  // if (ok) ok = SetAuxInsField2ActiveLine (*this, inSDIOutput, initParams.field2ActiveLine);
334  // if (ok) ok = SetAuxInsHActivePixels (*this, inSDIOutput, initParams.hActivePixels);
335  // if (ok) ok = SetAuxInsHTotalPixels (*this, inSDIOutput, initParams.hTotalPixels);
336  // if (ok) ok = SetAuxInsTotalLines (*this, inSDIOutput, initParams.totalLines);
337  // if (ok) ok = SetAuxInsFidLow (*this, inSDIOutput, extendedMode? initParams.field1SwitchLine : initParams.fidLow);
338  // if (ok) ok = SetAuxInsFidHi (*this, inSDIOutput, extendedMode? initParams.field2SwitchLine : initParams.fidHigh);
339  // if (ok) ok = SetAuxInsProgressive (*this, inSDIOutput, NTV2_IS_PROGRESSIVE_STANDARD(theStandard));
340  // if (ok) ok = SetAuxInsSDPacketSplit (*this, inSDIOutput, NTV2_IS_SD_STANDARD(theStandard));
341  // if (ok) ok = EnableAuxInsHauxC (*this, inSDIOutput, false);
342  // if (ok) ok = EnableAuxInsHauxY (*this, inSDIOutput, false);
343  // if (ok) ok = EnableAuxInsVauxC (*this, inSDIOutput, true);
344  // if (ok) ok = EnableAuxInsVauxY (*this, inSDIOutput, true);
345  // if (ok) ok = SetAuxInsHauxPixelDelay (*this, inSDIOutput, 0);
346  // if (ok) ok = SetAuxInsVauxPixelDelay (*this, inSDIOutput, 0);
347  // if (ok) ok = WriteRegister (AuxInsRegNum(inSDIOutput, regAuxInsBlankCStartLine), 0);
348  // if (ok) ok = WriteRegister (AuxInsRegNum(inSDIOutput, regAuxInsBlankField1CLines), 0);
349  // if (ok) ok = WriteRegister (AuxInsRegNum(inSDIOutput, regAuxInsBlankField2CLines), 0);
350  // if (ok) ok = WriteRegister (AuxInsRegNum(inSDIOutput, regAuxInsPixelDelay), extendedMode? initParams.pixelDelay : 0);
351 
352  // ULWord field1Bytes(0);
353  // ULWord field2Bytes(0);
354  // if (ok) ok = GetAuxField1Size(*this, field1Bytes);
355  // if (ok) ok = GetAuxField2Size(*this, field2Bytes);
356  // if (ok) ok = SetAuxInsField1Bytes (*this, inSDIOutput, field1Bytes);
357  // if (ok) ok = SetAuxInsField2Bytes (*this, inSDIOutput, field2Bytes);
358  // return ok;
359 
360  return false;
361 }
362 
363 bool CNTV2Card::AuxInsertSetComponents (const UWord inSDIOutput,
364  const bool inVauxY, const bool inVauxC,
365  const bool inHauxY, const bool inHauxC)
366 {
367  NTV2_UNUSED(inSDIOutput);
368  NTV2_UNUSED(inVauxY);
369  NTV2_UNUSED(inVauxC);
370  NTV2_UNUSED(inHauxY);
371  NTV2_UNUSED(inHauxC);
372  // bool ok(true);
373  // bool extendedMode(false);
374  // if (ok) ok = EnableAuxInsVauxY(*this, inSDIOutput, inVauxY);
375  // if (ok) ok = EnableAuxInsVauxC(*this, inSDIOutput, inVauxC);
376  // if (ok) ok = GetAuxInsExtendedMode (*this, inSDIOutput, extendedMode);
377  // if (extendedMode)
378  // {
379  // if (ok) ok = EnableAuxInsHauxY(*this, inSDIOutput, inHauxY);
380  // if (ok) ok = EnableAuxInsHauxC(*this, inSDIOutput, inHauxC);
381  // }
382  // return ok;
383 
384  return false;
385 }
386 
387 bool CNTV2Card::AuxInsertSetEnable (const UWord inSDIOutput, const bool inIsEnabled)
388 {
389  NTV2_UNUSED(inSDIOutput);
390  NTV2_UNUSED(inIsEnabled);
391  // if (!IsSupported(kDeviceCanDoPlayback))
392  // return false;
393  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
394  // return false;
395  // if (IS_OUTPUT_SPIGOT_INVALID(inSDIOutput))
396  // return false;
397  // bool ok(true);
398  // if (!inIsEnabled)
399  // {
400  // if (ok) ok = EnableAuxInsHauxC(*this, inSDIOutput, false);
401  // if (ok) ok = EnableAuxInsHauxY(*this, inSDIOutput, false);
402  // if (ok) ok = EnableAuxInsVauxC(*this, inSDIOutput, false);
403  // if (ok) ok = EnableAuxInsVauxY(*this, inSDIOutput, false);
404  // }
405  // if (ok) ok = WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsBlankCStartLine), 0);
406  // if (ok) ok = WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsBlankField1CLines), 0);
407  // if (ok) ok = WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsBlankField2CLines), 0);
408  // if (ok) ok = WriteRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), inIsEnabled ? 0 : 1, maskInsDisableInserter, shiftInsDisableInserter);
409  // return ok;
410 
411  return false;
412 }
413 
414 bool CNTV2Card::AuxInsertIsEnabled (const UWord inSDIOutput, bool & outIsRunning)
415 {
416  NTV2_UNUSED(inSDIOutput);
417  NTV2_UNUSED(outIsRunning);
418  // outIsRunning = false;
419  // if (!IsSupported(kDeviceCanDoPlayback))
420  // return false;
421  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
422  // return false;
423  // if (ULWord(inSDIOutput) >= GetNumSupported(kDeviceGetNumVideoOutputs))
424  // return false;
425 
426  // ULWord value(0);
427  // if (!ReadRegister(AuxInsRegNum(inSDIOutput, regAuxInsControl), value))
428  // return false;
429  // outIsRunning = (value & BIT(28)) ? false : true;
430  // return true;
431 
432  return false;
433 }
434 
435 bool CNTV2Card::AuxInsertSetReadParams (const UWord inSDIOutput, const ULWord inFrameNumber, const ULWord inF1Size,
436  const NTV2Channel inChannel, const NTV2Framesize inFrameSize)
437 {
438  NTV2_UNUSED(inSDIOutput);
439  NTV2_UNUSED(inFrameNumber);
440  NTV2_UNUSED(inF1Size);
441  NTV2_UNUSED(inChannel);
442  NTV2_UNUSED(inFrameSize);
443  // if (!IsSupported(kDeviceCanDoPlayback))
444  // return false;
445  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
446  // return false;
447  // if (IS_OUTPUT_SPIGOT_INVALID(inSDIOutput))
448  // return false;
449 
450  // NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inSDIOutput));
451  // NTV2Framesize theFrameSize(inFrameSize);
452  // if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
453  // {
454  // if (IS_CHANNEL_INVALID(theChannel))
455  // return false;
456  // if (!GetFrameBufferSize(theChannel, theFrameSize))
457  // return false;
458  // if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
459  // return false;
460  // }
461 
462  // bool ok(true);
463  // // Calculate where AUX Inserter will read the data
464  // const ULWord frameNumber (inFrameNumber + 1); // Start at beginning of next frame (then subtract offset later)
465  // ULWord frameLocation (::NTV2FramesizeToByteCount(theFrameSize) * frameNumber);
466  // bool quadEnabled(false), quadQuadEnabled(false);
467  // GetQuadFrameEnable(quadEnabled, inChannel);
468  // GetQuadQuadFrameEnable(quadQuadEnabled, inChannel);
469  // if (quadEnabled)
470  // frameLocation *= 4;
471  // if (quadQuadEnabled)
472  // frameLocation *= 4;
473 
474  // ULWord F1Offset(0);
475  // if (ok) ok = ReadRegister (kVRegAuxField1Offset, F1Offset);
476  // const ULWord AUXStartMemory (frameLocation - F1Offset);
477  // if (ok) ok = SetAuxInsField1StartAddr (*this, inSDIOutput, AUXStartMemory);
478  // if (ok) ok = SetAuxInsField1Bytes (*this, inSDIOutput, inF1Size);
479  // return ok;
480 
481  return false;
482 }
483 
484 bool CNTV2Card::AuxInsertSetField2ReadParams (const UWord inSDIOutput, const ULWord inFrameNumber, const ULWord inF2Size,
485  const NTV2Channel inChannel, const NTV2Framesize inFrameSize)
486 {
487  NTV2_UNUSED(inSDIOutput);
488  NTV2_UNUSED(inFrameNumber);
489  NTV2_UNUSED(inF2Size);
490  NTV2_UNUSED(inChannel);
491  NTV2_UNUSED(inFrameSize);
492  // if (!IsSupported(kDeviceCanDoPlayback))
493  // return false;
494  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
495  // return false;
496  // if (IS_OUTPUT_SPIGOT_INVALID(inSDIOutput))
497  // return false;
498 
499  // NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inSDIOutput));
500  // NTV2Framesize theFrameSize(inFrameSize);
501  // if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
502  // {
503  // if (IS_CHANNEL_INVALID(theChannel))
504  // return false;
505  // if (!GetFrameBufferSize(theChannel, theFrameSize))
506  // return false;
507  // if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
508  // return false;
509  // }
510 
511  // bool ok(true);
512  // // Calculate where AUX Inserter will read the data
513  // const ULWord frameNumber (inFrameNumber + 1); // Start at beginning of next frame (then subtract offset later)
514  // ULWord frameLocation (::NTV2FramesizeToByteCount(theFrameSize) * frameNumber);
515  // bool quadEnabled(false), quadQuadEnabled(false);
516  // GetQuadFrameEnable(quadEnabled, inChannel);
517  // GetQuadQuadFrameEnable(quadQuadEnabled, inChannel);
518  // if (quadEnabled)
519  // frameLocation *= 4;
520  // if (quadQuadEnabled)
521  // frameLocation *= 4;
522 
523  // ULWord F2Offset(0);
524  // if (ok) ok = ReadRegister (kVRegAuxField2Offset, F2Offset);
525  // const ULWord AUXStartMemory (frameLocation - F2Offset);
526  // if (ok) ok = SetAuxInsField2StartAddr (*this, inSDIOutput, AUXStartMemory);
527  // if (ok) ok = SetAuxInsField2Bytes (*this, inSDIOutput, inF2Size);
528  // return ok;
529 
530  return false;
531 }
532 
533 bool CNTV2Card::AuxInsertSetIPParams (const UWord inSDIOutput, const UWord auxChannel, const ULWord payloadID, const ULWord ssrc)
534 {
535  NTV2_UNUSED(inSDIOutput);
536  NTV2_UNUSED(auxChannel);
537  NTV2_UNUSED(payloadID);
538  NTV2_UNUSED(ssrc);
539  // bool ok(false);
540 
541  // if (IsSupported(kDeviceCanDoIP))
542  // {
543  // ok = SetAuxInsIPChannel (*this, inSDIOutput, auxChannel);
544  // if (ok) ok = SetAuxInsRtpPayloadID (*this, inSDIOutput, payloadID);
545  // if (ok) ok = SetAuxInsRtpSSRC (*this, inSDIOutput, ssrc);
546  // }
547  // return ok;
548 
549  return false;
550 }
551 
552 bool CNTV2Card::AuxInsertGetReadInfo (const UWord inSDIOutput, uint64_t & outF1StartAddr, uint64_t & outF2StartAddr)
553 {
554  NTV2_UNUSED(inSDIOutput);
555  NTV2_UNUSED(outF1StartAddr);
556  NTV2_UNUSED(outF2StartAddr);
557  // outF1StartAddr = outF2StartAddr = 0;
558  // if (!IsSupported(kDeviceCanDoPlayback))
559  // return false;
560  // if (!IsSupported(kDeviceCanDoHDMIAuxPlayback))
561  // return false;
562  // if (IS_OUTPUT_SPIGOT_INVALID(inSDIOutput))
563  // return false;
564  // return GetAuxInsStartAddrs (*this, inSDIOutput, outF1StartAddr, outF2StartAddr);
565 
566  return false;
567 }
568 
569 
573 
574 
575 static bool SetAuxExtProgressive (CNTV2Card & inDevice, const UWord inHDMIInput, bool bEnable)
576 {
577  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), bEnable ? 1 : 0, maskAuxSetProgressive, shiftAuxSetProgressive);
578 }
579 
580 static bool IsAuxExtProgressive (CNTV2DriverInterface & inDevice, const UWord inHDMIInput, bool & outIsProgressive)
581 {
582  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), outIsProgressive, maskAuxSetProgressive, shiftAuxSetProgressive);
583 }
584 
585 static bool SetAuxExtFilterMode (CNTV2Card & inDevice, const UWord inHDMIInput, bool bInclude)
586 {
587  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), bInclude ? 1 : 0, maskAuxFilterInvert, shiftAuxFilterInvert);
588 }
589 
590 static bool IsAuxExtFilterModeInclude (CNTV2DriverInterface & inDevice, const UWord inHDMIInput, bool & outIsInclude)
591 {
592  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), outIsInclude, maskAuxFilterInvert, shiftAuxFilterInvert);
593 }
594 
595 static bool SetAuxExtSynchro (CNTV2Card & inDevice, const UWord inHDMIInput)
596 {
597  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), 0x1, maskAuxSyncro, shiftAuxSyncro);
598 }
599 
600 static bool GetAuxExtField1StartAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t & outAddr)
601 {
602  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtField1StartAddress), outAddr);
603 }
604 
605 static bool SetAuxExtField1StartAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t addr)
606 {
607  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtField1StartAddress), addr);
608 }
609 
610 static bool GetAuxExtField1EndAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t & outAddr)
611 {
612  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtField1EndAddress), outAddr);
613 }
614 
615 static bool SetAuxExtField1EndAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t addr)
616 {
617  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtField1EndAddress), addr);
618 }
619 
620 static bool GetAuxExtField2StartAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t & outAddr)
621 {
622  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtField2StartAddress), outAddr);
623 }
624 
625 static bool SetAuxExtField2StartAddr (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t addr)
626 {
627  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtField2StartAddress), addr);
628 }
629 
630 static bool GetAuxExtField1Status (CNTV2DriverInterface & inDevice, const UWord inHDMIInput, ULWord & outF1Status)
631 {
632  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtField1Status), outF1Status);
633 }
634 
635 static bool GetAuxExtField2Status (CNTV2DriverInterface & inDevice, const UWord inHDMIInput, ULWord & outF2Status)
636 {
637  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtField2Status), outF2Status);
638 }
639 
640 static bool IsAuxExtOverrun (CNTV2DriverInterface & inDevice, const UWord inHDMIInput, bool & outIsOverrun)
641 {
642  return inDevice.ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtTotalStatus), outIsOverrun, maskAuxTotalOverrun, shiftAuxTotalOverrun);
643 }
644 
645 static bool SetAuxExtField1StartLine (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t lineNumber)
646 {
647  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtFieldVBLStartLine), lineNumber, maskAuxField1StartLine, shiftAuxField1StartLine);
648 }
649 
650 static bool SetAuxExtField2StartLine (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t lineNumber)
651 {
652  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtFieldVBLStartLine), lineNumber, maskAuxField2StartLine, shiftAuxField2StartLine);
653 }
654 
655 static bool SetAuxExtTotalFrameLines (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t totalFrameLines)
656 {
657  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtTotalFrameLines), totalFrameLines, maskAuxTotalFrameLines, shiftAuxTotalFrameLines);
658 }
659 
660 static bool SetAuxExtFidLow (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t lineNumber)
661 {
662  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtFID), lineNumber, maskAuxFIDLow, shiftAuxFIDLow);
663 }
664 
665 static bool SetAuxExtFidHi (CNTV2Card & inDevice, const UWord inHDMIInput, uint32_t lineNumber)
666 {
667  return inDevice.WriteRegister(AuxExtRegNum(inHDMIInput, regAuxExtFID), lineNumber, maskAuxFIDHi, shiftAuxFIDHi);
668 }
669 
670 bool CNTV2Card::AuxExtractInit (const UWord inHDMIInput, const NTV2Channel inChannel, const NTV2Standard inStandard)
671 {
672  if (!IsSupported(kDeviceCanDoCapture))
673  return false;
674  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
675  return false;
676  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
677  return false;
678 
679  NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inHDMIInput));
680  NTV2Standard theStandard (inStandard);
681  if (!NTV2_IS_VALID_STANDARD(theStandard))
682  {
683  if (IS_CHANNEL_INVALID(theChannel))
684  return false;
685  if (!GetStandard(theStandard, theChannel))
686  return false;
687  if (!NTV2_IS_VALID_STANDARD(theStandard))
688  return false;
689  }
690 
691  const AUXExtractorInitParams & extractorParams (extractorInitParamsTable[theStandard]);
692  bool ok(true);
693  if (ok) ok = SetAuxExtProgressive (*this, inHDMIInput, NTV2_IS_PROGRESSIVE_STANDARD(theStandard));
694  if (ok) ok = SetAuxExtField1StartLine (*this, inHDMIInput, extractorParams.field1StartLine);
695  if (ok) ok = SetAuxExtField2StartLine (*this, inHDMIInput, extractorParams.field2StartLine);
696  if (ok) ok = SetAuxExtTotalFrameLines (*this, inHDMIInput, extractorParams.totalLines);
697  if (ok) ok = SetAuxExtFidLow (*this, inHDMIInput, extractorParams.fidLow);
698  if (ok) ok = SetAuxExtFidHi (*this, inHDMIInput, extractorParams.fidHigh);
699  if (ok) ok = AuxExtractSetPacketFilters (inHDMIInput, AuxExtractGetDefaultPacketFilters());
700  if (ok) ok = SetAuxExtSynchro (*this, inHDMIInput);
701  if (ok) ok = SetAuxExtField1StartAddr (*this, inHDMIInput, 0);
702  if (ok) ok = SetAuxExtField1EndAddr (*this, inHDMIInput, 0);
703  if (ok) ok = SetAuxExtField2StartAddr (*this, inHDMIInput, 0);
704  return ok;
705 }
706 
707 bool CNTV2Card::AuxExtractSetEnable (const UWord inHDMIInput, const bool inIsEnabled)
708 {
709  if (!IsSupported(kDeviceCanDoCapture))
710  return false;
711  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
712  return false;
713  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
714  return false;
715 
716  bool ok(true);
717  if (ok) ok = WriteRegister (AuxExtRegNum(inHDMIInput, regAuxExtControl), inIsEnabled ? 0 : 1, maskAuxDisableExtractor, shiftAuxDisableExtractor);
718  return ok;
719 }
720 
721 bool CNTV2Card::AuxExtractIsEnabled (const UWord inHDMIInput, bool & outIsRunning)
722 {
723  outIsRunning = false;
724  if (!IsSupported(kDeviceCanDoCapture))
725  return false;
726  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
727  return false;
728  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
729  return false;
730 
731  ULWord value(0);
732  if (!ReadRegister(AuxExtRegNum(inHDMIInput, regAuxExtControl), value))
733  return false;
734  outIsRunning = (value & maskAuxDisableExtractor) ? false : true;
735  return true;
736 }
737 
738 bool CNTV2Card::AuxExtractSetWriteParams (const UWord inHDMIInput, const ULWord inFrameNumber,
739  const NTV2Channel inChannel, const NTV2Framesize inFrameSize)
740 {
741  if (!IsSupported(kDeviceCanDoCapture))
742  return false;
743  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
744  return false;
745  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
746  return false;
747 
748  NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inHDMIInput));
749  NTV2Framesize theFrameSize(inFrameSize);
750  if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
751  {
752  if (IS_CHANNEL_INVALID(theChannel))
753  return false;
754  if (!GetFrameBufferSize(theChannel, theFrameSize))
755  return false;
756  if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
757  return false;
758  }
759  if (IS_CHANNEL_INVALID(theChannel))
760  return false;
761 
762  // Calculate where AUX Extractor will put the data...
763  bool ok (true);
764  const ULWord nextFrame (inFrameNumber + 1); // This is so the next calculation will point to the beginning of the next frame - subtract offset for memory start
765  ULWord endOfFrameLocation (::NTV2FramesizeToByteCount(theFrameSize) * nextFrame);
766 
767  bool quadEnabled(false), quadQuadEnabled(false);
768  GetQuadFrameEnable(quadEnabled, inChannel);
769  GetQuadQuadFrameEnable(quadQuadEnabled, inChannel);
770  if (quadEnabled)
771  endOfFrameLocation *= 4;
772  if (quadQuadEnabled)
773  endOfFrameLocation *= 4;
774 
775  ULWord F1Offset(0), F2Offset(0);
776  if (ok) ok = GetAuxOffsets (*this, F1Offset, F2Offset);
777 
778  const ULWord AUXStartMemory (endOfFrameLocation - F1Offset);
779  const ULWord AUXStopMemory (endOfFrameLocation - F2Offset - 1);
780  if (ok) ok = SetAuxExtField1StartAddr (*this, inHDMIInput, AUXStartMemory);
781  if (ok) ok = SetAuxExtField1EndAddr (*this, inHDMIInput, AUXStopMemory);
782  return ok;
783 }
784 
785 bool CNTV2Card::AuxExtractSetField2WriteParams (const UWord inHDMIInput, const ULWord inFrameNumber,
786  const NTV2Channel inChannel, const NTV2Framesize inFrameSize)
787 {
788  if (!IsSupported(kDeviceCanDoCapture))
789  return false;
790  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
791  return false;
792  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
793  return false;
794 
795  NTV2Channel theChannel (NTV2_IS_VALID_CHANNEL(inChannel) ? inChannel : NTV2Channel(inHDMIInput));
796  NTV2Framesize theFrameSize(inFrameSize);
797  if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
798  {
799  if (IS_CHANNEL_INVALID(theChannel))
800  return false;
801  if (!GetFrameBufferSize(theChannel, theFrameSize))
802  return false;
803  if (!NTV2_IS_VALID_8MB_FRAMESIZE(theFrameSize))
804  return false;
805  }
806  if (IS_CHANNEL_INVALID(theChannel))
807  return false;
808 
809  // Calculate where AUX Extractor will put the data...
810  bool ok (true);
811  const ULWord frameNumber (inFrameNumber + 1); // This is so the next calculation will point to the beginning of the next frame - subtract offset for memory start
812  ULWord frameLocation (::NTV2FramesizeToByteCount(theFrameSize) * frameNumber);
813 
814  bool quadEnabled(false), quadQuadEnabled(false);
815  GetQuadFrameEnable(quadEnabled, inChannel);
816  GetQuadQuadFrameEnable(quadQuadEnabled, inChannel);
817  if (quadEnabled)
818  frameLocation *= 4;
819  if (quadQuadEnabled)
820  frameLocation *= 4;
821 
822  ULWord F2Offset(0);
823  if (ok) ok = ReadRegister(kVRegAncField2Offset, F2Offset);
824 
825  const ULWord AUXStartMemory (frameLocation - F2Offset);
826  //const ULWord AUXStopMemory (frameLocation - 1);
827  if (ok) ok = SetAuxExtField2StartAddr (*this, inHDMIInput, AUXStartMemory);
828 
829  NTV2_UNUSED(ok);
830  // For HDMI Aux, we do not have a register defined to store the end of Field 2 Aux Buffer.
831  // It is assumed to be the same size as field 1.
832  // if (ok) ok = SetAuxExtField2EndAddr (*this, inHDMIInput, AUXStopMemory);
833  return true;
834 }
835 
836 bool CNTV2Card::AuxExtractGetWriteInfo (const UWord inHDMIInput,
837  uint64_t & outF1StartAddr, uint64_t & outF1EndAddr,
838  uint64_t & outF2StartAddr, uint64_t & outF2EndAddr)
839 {
840  outF1StartAddr = outF1EndAddr = outF2StartAddr = outF2EndAddr = 0;
841  if (!IsSupported(kDeviceCanDoCapture))
842  return false;
843  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
844  return false;
845  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
846  return false;
847 
848  ULWord startAddr(0), endAddr(0);
849  bool ok = GetAuxExtField1StartAddr(*this, inHDMIInput, startAddr) && GetAuxExtField1EndAddr(*this, inHDMIInput, endAddr);
850  outF1StartAddr = uint64_t(startAddr);
851  outF1EndAddr = uint64_t(endAddr);
852  //Question: Ok to return 0 for outF2EndAddr.. Answer: No
853  ok = ok && GetAuxExtField2StartAddr(*this, inHDMIInput, startAddr); // && GetAuxExtField2EndAddr(*this, inHDMIInput, endAddr);
854  outF2StartAddr = uint64_t(startAddr);
855  //For HDMI Aux, we are not storing this value in a register. Calcuate based on the same buffer size as Field 1
856  outF2EndAddr = uint64_t(startAddr) + (outF1EndAddr - outF1StartAddr);
857  return ok;
858 }
859 
860 bool CNTV2Card::AuxExtractGetPacketFilters (const UWord inHDMIInput, NTV2DIDSet & outFilters)
861 {
862  outFilters.clear();
863  if (!IsSupported(kDeviceCanDoCapture))
864  return false;
865  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
866  return false;
867  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
868  return false;
869 
870  const ULWord firstIgnoreRegNum (AuxExtRegNum(inHDMIInput, regAuxExtPacketMask_First));
871  for (ULWord regNdx(0); regNdx < kNumDIDRegisters; regNdx++)
872  {
873  ULWord regValue (0);
874  ReadRegister (firstIgnoreRegNum + regNdx, regValue);
875  for (unsigned regByte(0); regByte < 4; regByte++)
876  {
877  const NTV2DID theDID ((regValue >> (regByte*8)) & 0x000000FF);
878  if (theDID)
879  outFilters.insert(theDID);
880  }
881  }
882 
883  return true;
884 }
885 
886 bool CNTV2Card::AuxExtractSetPacketFilters (const UWord inHDMIInput, const NTV2DIDSet & inDIDs)
887 {
888  if (!IsSupported(kDeviceCanDoCapture))
889  return false;
890  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
891  return false;
892  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
893  return false;
894 
895  const ULWord firstIgnoreRegNum (AuxExtRegNum(inHDMIInput, regAuxExtPacketMask_First));
896  NTV2DIDSetConstIter iter (inDIDs.begin());
897 
898  for (ULWord regNdx(0); regNdx < kNumDIDRegisters; regNdx++)
899  {
900  ULWord regValue (0);
901  for (unsigned regByte(0); regByte < 4; regByte++)
902  {
903  const NTV2DID theDID (iter != inDIDs.end() ? *iter++ : 0);
904  regValue |= (ULWord(theDID) << (regByte*8));
905  }
906  WriteRegister (firstIgnoreRegNum + regNdx, regValue);
907  }
908  return true;
909 }
910 
911 
912 bool CNTV2Card::AuxExtractSetFilterInclusionMode (const UWord inHDMIInput, const bool inIncludePackets)
913 {
914  if (!IsSupported(kDeviceCanDoCapture))
915  return false;
916  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
917  return false;
918  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
919  return false;
920 
921  bool ok = SetAuxExtFilterMode(*this, inHDMIInput, inIncludePackets);
922  return ok;
923 
924 }
925 
926 bool CNTV2Card::AuxExtractGetFilterInclusionMode (const UWord inHDMIInput, bool & outIncludePackets)
927 {
928  if (!IsSupported(kDeviceCanDoCapture))
929  return false;
930  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
931  return false;
932  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
933  return false;
934 
935  bool ok = IsAuxExtFilterModeInclude(*this, inHDMIInput, outIncludePackets);
936  return ok;
937 }
938 
939 
940 bool CNTV2Card::AuxExtractGetField1Size (const UWord inHDMIInput, ULWord & outF1Size)
941 {
942  outF1Size = 0;
943  if (!IsSupported(kDeviceCanDoCapture))
944  return false;
945  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
946  return false;
947  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
948  return false;
949 
950  bool ok (true);
951  ULWord regValue (0);
952 
953  ok = GetAuxExtField1Status(*this, inHDMIInput, regValue);
954  if (!ok || ((regValue & maskAuxFieldOverrun) != 0))
955  return false;
956  outF1Size = regValue & maskAuxFieldBytesIn;
957 
958  return ok;
959 }
960 
961 bool CNTV2Card::AuxExtractGetField2Size (const UWord inHDMIInput, ULWord & outF2Size)
962 {
963  outF2Size = 0;
964  if (!IsSupported(kDeviceCanDoCapture))
965  return false;
966  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
967  return false;
968  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
969  return false;
970 
971  bool ok (true);
972  ULWord regValue (0);
973 
974  ok = GetAuxExtField2Status(*this, inHDMIInput, regValue);
975  if (!ok || ((regValue & maskAuxFieldOverrun) != 0))
976  return false;
977  outF2Size = regValue & maskAuxFieldBytesIn;
978 
979  return ok;
980 }
981 
982 bool CNTV2Card::AuxExtractGetBufferOverrun (const UWord inHDMIInput, bool & outIsOverrun, const UWord inField)
983 {
984  outIsOverrun = false;
985  if (!IsSupported(kDeviceCanDoCapture))
986  return false;
987  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
988  return false;
989  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
990  return false;
991  if (inField > 2)
992  return false;
993  ULWord status(0);
994  switch (inField)
995  {
996  case 0: return IsAuxExtOverrun (*this, inHDMIInput, outIsOverrun);
997  case 1: if (!GetAuxExtField1Status(*this, inHDMIInput, status))
998  return false;
999  outIsOverrun = (status & maskAuxFieldOverrun) ? true : false;
1000  return true;
1001  case 2: if (!GetAuxExtField2Status(*this, inHDMIInput, status))
1002  return false;
1003  outIsOverrun = (status & maskAuxFieldOverrun) ? true : false;
1004  return true;
1005  default: break;
1006  }
1007  return false;
1008 }
1009 
1010 bool CNTV2Card::AuxExtractIsProgressive (const UWord inHDMIInput, bool & outIsProgressive)
1011 {
1012  if (!IsSupported(kDeviceCanDoCapture))
1013  return false;
1014  if (!IsSupported(kDeviceCanDoHDMIAuxCapture))
1015  return false;
1016  if (IS_HDMI_INPUT_SPIGOT_INVALID(inHDMIInput))
1017  return false;
1018 
1019  return IsAuxExtProgressive (*this, inHDMIInput, outIsProgressive);
1020 }
1021 
1022 
1023 
1027 
1028 UWord CNTV2Card::AuxExtractGetMaxNumPacketFilters (void)
1029 {
1030  static const ULWord kNumDIDsPerRegister (4);
1031  return UWord(kNumDIDsPerRegister * kNumDIDRegisters);
1032 }
1033 
1034 NTV2DIDSet CNTV2Card::AuxExtractGetDefaultPacketFilters (void)
1035 {
1036  static const NTV2DID sDefaultHDDIDs[] = {0x02, 0x00};
1037  // Packet type 0x02: Audio Sample (L-PCM and IEC 61937 compressed formats)
1038 
1039  NTV2DIDSet result;
1040  const NTV2DID * pDIDArray (sDefaultHDDIDs);
1041  for (unsigned ndx(0); pDIDArray[ndx]; ndx++)
1042  result.insert(pDIDArray[ndx]);
1043 
1044  return result;
1045 }
kVRegAncField2Offset
Anc Field2 byte offset from end of frame buffer (GUMP on all boards except RTP for SMPTE2022/IP) ...
Definition: ntv2virtualregisters.h:338
CNTV2DriverInterface::IsSupported
virtual bool IsSupported(const NTV2BoolParamID inParamID)
Definition: ntv2driverinterface.h:419
AUXExtractorInitParams::field2AnalogCFilter
uint32_t field2AnalogCFilter
Definition: ntv2aux.cpp:103
CNTV2Card::AuxExtractSetWriteParams
virtual bool AuxExtractSetWriteParams(const UWord inHDMIInput, const ULWord inFrameNumber, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Framesize inFrameSize=NTV2_FRAMESIZE_INVALID)
Configures the given HDMI input&#39;s Aux extractor to receive the next frame&#39;s F1 Aux data...
Definition: ntv2aux.cpp:738
CNTV2Card
I interrogate and control an AJA video/audio capture/playout device.
Definition: ntv2card.h:28
CNTV2Card::AuxExtractGetField2Size
virtual bool AuxExtractGetField2Size(const UWord inHDMIInput, ULWord &outF2Size)
Answers with the number of bytes of field 2 HDMI AUX data extracted.
Definition: ntv2aux.cpp:961
NTV2DID
UByte NTV2DID
An ancillary Data IDentifier.
Definition: ntv2publicinterface.h:75
GetAuxOffsets
static bool GetAuxOffsets(CNTV2Card &inDevice, ULWord &outF1Offset, ULWord &outF2Offset)
Definition: ntv2aux.cpp:135
CNTV2Card::AuxExtractGetField1Size
virtual bool AuxExtractGetField1Size(const UWord inHDMIInput, ULWord &outF1Size)
Answers with the number of bytes of field 1 ANC extracted.
Definition: ntv2aux.cpp:940
CNTV2Card::AuxExtractGetPacketFilters
virtual bool AuxExtractGetPacketFilters(const UWord inHDMIInput, NTV2DIDSet &outDIDs)
Answers with the HDMI packet types currently being excluded (filtered) by the HDMI input&#39;s Aux extrac...
Definition: ntv2aux.cpp:860
GetAuxExtField2Status
static bool GetAuxExtField2Status(CNTV2DriverInterface &inDevice, const UWord inHDMIInput, ULWord &outF2Status)
Definition: ntv2aux.cpp:635
AUXExtractorInitParams::field1CutoffLine
uint32_t field1CutoffLine
Definition: ntv2aux.cpp:90
GetAuxExtField1EndAddr
static bool GetAuxExtField1EndAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t &outAddr)
Definition: ntv2aux.cpp:610
CNTV2Card::AuxInsertSetReadParams
virtual bool AuxInsertSetReadParams(const UWord inHDMIOutput, const ULWord inFrameNumber, const ULWord inF1Size, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Framesize inFrameSize=NTV2_FRAMESIZE_INVALID)
Configures the Aux inserter for the next frame&#39;s F1 Aux data to embed/transmit.
Definition: ntv2aux.cpp:435
AUXExtractorInitParams
struct AUXExtractorInitParams AUXExtractorInitParams
AuxExtRegNum
static ULWord AuxExtRegNum(const UWord inHDMIInput, const AUXExtRegisters inReg)
Definition: ntv2aux.cpp:37
IsAuxExtFilterModeInclude
static bool IsAuxExtFilterModeInclude(CNTV2DriverInterface &inDevice, const UWord inHDMIInput, bool &outIsInclude)
Definition: ntv2aux.cpp:590
AUXExtractorInitParams::field1AnalogYFilter
uint32_t field1AnalogYFilter
Definition: ntv2aux.cpp:100
SetAuxExtTotalFrameLines
static bool SetAuxExtTotalFrameLines(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t totalFrameLines)
Definition: ntv2aux.cpp:655
GetAuxExtField1StartAddr
static bool GetAuxExtField1StartAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t &outAddr)
Definition: ntv2aux.cpp:600
AUXExtractorInitParams::field2SwitchLine
uint32_t field2SwitchLine
Definition: ntv2aux.cpp:97
CNTV2DriverInterface::GetFrameBufferSize
virtual ULWord GetFrameBufferSize(void) const
Definition: ntv2driverinterface.h:380
extractorInitParamsTable
static const AUXExtractorInitParams extractorInitParamsTable[NTV2_NUM_STANDARDS]
Definition: ntv2aux.cpp:107
ULWord
uint32_t ULWord
Definition: ajatypes.h:223
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They&#39;re also commonly use...
Definition: ntv2enums.h:1357
CNTV2Card::AuxInsertGetReadInfo
virtual bool AuxInsertGetReadInfo(const UWord inHDMIOutput, uint64_t &outF1StartAddr, uint64_t &outF2StartAddr)
Answers where, in device SDRAM, the given HDMI connector&#39;s Aux inserter is currently reading Aux data...
Definition: ntv2aux.cpp:552
SetAuxExtField1StartAddr
static bool SetAuxExtField1StartAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t addr)
Definition: ntv2aux.cpp:605
SetAuxExtField1StartLine
static bool SetAuxExtField1StartLine(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t lineNumber)
Definition: ntv2aux.cpp:645
kVRegAncField1Offset
Anc Field1 byte offset from end of frame buffer (GUMP on all boards except RTP for SMPTE2022/IP) ...
Definition: ntv2virtualregisters.h:337
SetAuxExtSynchro
static bool SetAuxExtSynchro(CNTV2Card &inDevice, const UWord inHDMIInput)
Definition: ntv2aux.cpp:595
CNTV2Card::AuxInsertSetEnable
virtual bool AuxInsertSetEnable(const UWord inHDMIOutput, const bool inIsEnabled)
Enables or disables the given HDMI output&#39;s Aux inserter frame buffer reads.
Definition: ntv2aux.cpp:387
CNTV2DriverInterface
I&#39;m the base class that undergirds the platform-specific derived classes (from which CNTV2Card is ult...
Definition: ntv2driverinterface.h:60
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:165
CNTV2Card::GetQuadFrameEnable
virtual bool GetQuadFrameEnable(bool &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device&#39;s current quad-frame mode, whether it&#39;s enabled or not.
Definition: ntv2register.cpp:1207
CNTV2Card::AuxInsertIsEnabled
virtual bool AuxInsertIsEnabled(const UWord inHDMIOutput, bool &outIsEnabled)
Answers with the run state of the given Aux inserter – i.e. if its "memory reader" is enabled or not...
Definition: ntv2aux.cpp:414
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:445
kNumDIDRegisters
static const ULWord kNumDIDRegisters(regAuxExtPacketMask_Last - regAuxExtPacketMask_First+1)
NTV2FramesizeToByteCount
ULWord NTV2FramesizeToByteCount(const NTV2Framesize inFrameSize)
Converts the given NTV2Framesize value into an exact byte count.
Definition: ntv2utils.cpp:5287
IsAuxExtProgressive
static bool IsAuxExtProgressive(CNTV2DriverInterface &inDevice, const UWord inHDMIInput, bool &outIsProgressive)
Definition: ntv2aux.cpp:580
sAuxExtBaseRegNum
static const ULWord sAuxExtBaseRegNum[]
Definition: ntv2aux.cpp:28
NTV2_IS_VALID_8MB_FRAMESIZE
#define NTV2_IS_VALID_8MB_FRAMESIZE(__x__)
Definition: ntv2enums.h:2139
CNTV2Card::AuxExtractIsProgressive
virtual bool AuxExtractIsProgressive(const UWord inHDMIInput, bool &outIsProgressive)
Answers whether or not the given HDMI input&#39;s Aux extractor was configured with a progressive video f...
Definition: ntv2aux.cpp:1010
CNTV2Card::AuxInsertInit
virtual bool AuxInsertInit(const UWord inHDMIOutput, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Standard inStandard=NTV2_STANDARD_INVALID)
Initializes the given HDMI output&#39;s Aux inserter for custom Aux packet insertion. ...
Definition: ntv2aux.cpp:304
CNTV2Card::IS_HDMI_INPUT_SPIGOT_INVALID
virtual bool IS_HDMI_INPUT_SPIGOT_INVALID(const UWord inInputHDMIPort)
Definition: ntv2card.cpp:302
NTV2_IS_VALID_STANDARD
#define NTV2_IS_VALID_STANDARD(__s__)
Definition: ntv2enums.h:188
SetAuxExtField2StartAddr
static bool SetAuxExtField2StartAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t addr)
Definition: ntv2aux.cpp:625
AUXExtractorInitParams::field1AnalogCFilter
uint32_t field1AnalogCFilter
Definition: ntv2aux.cpp:102
AUXExtractorInitParams::field1StartLine
uint32_t field1StartLine
Definition: ntv2aux.cpp:89
AUXExtractorInitParams::field2CutoffLine
uint32_t field2CutoffLine
Definition: ntv2aux.cpp:92
CNTV2Card::AuxInsertSetField2ReadParams
virtual bool AuxInsertSetField2ReadParams(const UWord inHDMIOutput, const ULWord inFrameNumber, const ULWord inF2Size, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Framesize inFrameSize=NTV2_FRAMESIZE_INVALID)
Configures the Aux inserter for the next frame&#39;s F2 Aux data to embed/transmit.
Definition: ntv2aux.cpp:484
NTV2DIDSetConstIter
NTV2DIDSet::const_iterator NTV2DIDSetConstIter
Handy const iterator to iterate over an NTV2DIDSet.
Definition: ntv2publicinterface.h:78
CNTV2Card::GetQuadQuadFrameEnable
virtual bool GetQuadQuadFrameEnable(bool &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Returns the device&#39;s current "quad-quad" frame mode, whether it&#39;s enabled or not. ...
Definition: ntv2register.cpp:1222
AUXExtractorInitParams::field2AnalogYFilter
uint32_t field2AnalogYFilter
Definition: ntv2aux.cpp:101
kDeviceCanDoCapture
True if device has any SDI, HDMI or analog video inputs.
Definition: ntv2devicefeatures.h:55
SetAuxExtField1EndAddr
static bool SetAuxExtField1EndAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t addr)
Definition: ntv2aux.cpp:615
CNTV2Card::AuxExtractGetWriteInfo
virtual bool AuxExtractGetWriteInfo(const UWord inHDMIInput, uint64_t &outF1StartAddr, uint64_t &outF1EndAddr, uint64_t &outF2StartAddr, uint64_t &outF2EndAddr)
Answers with the given HDMI input&#39;s current Aux extractor info.
Definition: ntv2aux.cpp:836
CNTV2MacDriverInterface::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: ntv2macdriverinterface.cpp:405
NTV2Framesize
NTV2Framesize
Kona2/Xena2 specific enums.
Definition: ntv2enums.h:2116
CNTV2Card::AuxExtractGetMaxNumPacketFilters
static UWord AuxExtractGetMaxNumPacketFilters(void)
Definition: ntv2aux.cpp:1028
GetAuxExtField1Status
static bool GetAuxExtField1Status(CNTV2DriverInterface &inDevice, const UWord inHDMIInput, ULWord &outF1Status)
Definition: ntv2aux.cpp:630
AUXExtractorInitParams::field2AnalogStartLine
uint32_t field2AnalogStartLine
Definition: ntv2aux.cpp:99
NTV2_IS_VALID_CHANNEL
#define NTV2_IS_VALID_CHANNEL(__x__)
Definition: ntv2enums.h:1371
CNTV2Card::AuxExtractSetEnable
virtual bool AuxExtractSetEnable(const UWord inHDMIInput, const bool inIsEnabled)
Enables or disables the given HDMI input&#39;s Aux extractor.
Definition: ntv2aux.cpp:707
CNTV2Card::AuxExtractIsEnabled
virtual bool AuxExtractIsEnabled(const UWord inHDMIInput, bool &outIsEnabled)
Answers whether the given HDMI input&#39;s Aux extractor is enabled/active or not.
Definition: ntv2aux.cpp:721
AUXExtractorInitParams::analogActiveLineLength
uint32_t analogActiveLineLength
Definition: ntv2aux.cpp:104
CNTV2Card::AuxExtractSetPacketFilters
virtual bool AuxExtractSetPacketFilters(const UWord inHDMIInput, const NTV2DIDSet &inDIDs)
Replaces the HDMI packet types to be excluded (filtered) by the given HDMI input&#39;s Aux extractor...
Definition: ntv2aux.cpp:886
AUXExtractorInitParams::field1AnalogStartLine
uint32_t field1AnalogStartLine
Definition: ntv2aux.cpp:98
SetAuxExtFidLow
static bool SetAuxExtFidLow(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t lineNumber)
Definition: ntv2aux.cpp:660
SetAuxExtProgressive
static bool SetAuxExtProgressive(CNTV2Card &inDevice, const UWord inHDMIInput, bool bEnable)
Definition: ntv2aux.cpp:575
ntv2utils.h
Declares numerous NTV2 utility functions.
CNTV2Card::AuxExtractInit
virtual bool AuxExtractInit(const UWord inHDMIInput, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Standard inStandard=NTV2_STANDARD_INVALID)
Initializes the given HDMI input&#39;s Aux extractor for custom Aux packet detection and de-embedding...
Definition: ntv2aux.cpp:670
IsAuxExtOverrun
static bool IsAuxExtOverrun(CNTV2DriverInterface &inDevice, const UWord inHDMIInput, bool &outIsOverrun)
Definition: ntv2aux.cpp:640
CNTV2Card::AuxExtractGetBufferOverrun
virtual bool AuxExtractGetBufferOverrun(const UWord inHDMIInput, bool &outIsOverrun, const UWord inField=0)
Answers whether or not the given HDMI input&#39;s Aux extractor reached its buffer limits.
Definition: ntv2aux.cpp:982
CNTV2Card::AuxExtractSetField2WriteParams
virtual bool AuxExtractSetField2WriteParams(const UWord inHDMIInput, const ULWord inFrameNumber, const NTV2Channel inChannel=NTV2_CHANNEL_INVALID, const NTV2Framesize inFrameSize=NTV2_FRAMESIZE_INVALID)
Configures the given HDMI input&#39;s Aux extractor to receive the next frame&#39;s F2 Aux data...
Definition: ntv2aux.cpp:785
GetAuxExtField2StartAddr
static bool GetAuxExtField2StartAddr(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t &outAddr)
Definition: ntv2aux.cpp:620
NTV2_UNUSED
#define NTV2_UNUSED(__p__)
Definition: ajatypes.h:132
UWord
uint16_t UWord
Definition: ajatypes.h:221
CNTV2MacDriverInterface::WriteRegister
virtual bool WriteRegister(const ULWord inRegNum, const ULWord inValue, const ULWord inMask=0xFFFFFFFF, const ULWord inShift=0)
Updates or replaces all or part of the 32-bit contents of a specific register (real or virtual) on th...
Definition: ntv2macdriverinterface.cpp:454
CNTV2Card::AuxInsertSetIPParams
virtual bool AuxInsertSetIPParams(const UWord inHDMIOutput, const UWord auxChannel, const ULWord payloadID, const ULWord ssrc)
Configures the Aux inserter IP specific params.
Definition: ntv2aux.cpp:533
CNTV2Card::AuxInsertSetComponents
virtual bool AuxInsertSetComponents(const UWord inHDMIOutput, const bool inVauxY, const bool inVauxC, const bool inHauxY, const bool inHauxC)
Enables or disables individual Aux insertion components for the given HDMI output.
Definition: ntv2aux.cpp:363
ntv2formatdescriptor.h
Declares the NTV2FormatDescriptor class.
kDeviceCanDoHDMIAuxCapture
True if device has HDMI AUX data extractor(s).
Definition: ntv2devicefeatures.h:123
CNTV2Card::IS_CHANNEL_INVALID
virtual bool IS_CHANNEL_INVALID(const NTV2Channel inChannel) const
Definition: ntv2card.cpp:274
ntv2card.h
Declares the CNTV2Card class.
SetAuxExtField2StartLine
static bool SetAuxExtField2StartLine(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t lineNumber)
Definition: ntv2aux.cpp:650
SetAuxExtFidHi
static bool SetAuxExtFidHi(CNTV2Card &inDevice, const UWord inHDMIInput, uint32_t lineNumber)
Definition: ntv2aux.cpp:665
SetAuxExtFilterMode
static bool SetAuxExtFilterMode(CNTV2Card &inDevice, const UWord inHDMIInput, bool bInclude)
Definition: ntv2aux.cpp:585
CNTV2Card::AuxExtractGetDefaultPacketFilters
static NTV2DIDSet AuxExtractGetDefaultPacketFilters(void)
Definition: ntv2aux.cpp:1034
CNTV2Card::AuxExtractGetFilterInclusionMode
virtual bool AuxExtractGetFilterInclusionMode(const UWord inHDMIInput, bool &outEnabled)
Answers whether or not HDMI AUX packet filtering is enabled for the given HDMI input.
Definition: ntv2aux.cpp:926
CNTV2Card::AuxExtractSetFilterInclusionMode
virtual bool AuxExtractSetFilterInclusionMode(const UWord inHDMIInput, const bool inEnable)
Enables or disables HDMI AUX packet filtering for the given HDMI input.
Definition: ntv2aux.cpp:912
AUXExtractorInitParams::field2StartLine
uint32_t field2StartLine
Definition: ntv2aux.cpp:91
CNTV2Card::GetStandard
virtual bool GetStandard(NTV2Standard &outValue, NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2register.cpp:826
NTV2_IS_PROGRESSIVE_STANDARD
#define NTV2_IS_PROGRESSIVE_STANDARD(__s__)
Definition: ntv2enums.h:189
AUXExtractorInitParams::field1SwitchLine
uint32_t field1SwitchLine
Definition: ntv2aux.cpp:96
ntv2devicefeatures.h
Declares device capability functions.
NTV2DIDSet
std::set< UByte > NTV2DIDSet
A set of distinct NTV2DID values.
Definition: ntv2publicinterface.h:76