AJA NTV2 SDK  18.1.0.2145
NTV2 SDK 18.1.0.2145
ntv2hdmi.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 #if defined (AJALinux)
12  //#include "ntv2linuxpublicinterface.h"
13 #elif defined (MSWindows)
14  #pragma warning(disable: 4800)
15 #endif
16 
17 using namespace std;
18 
19 
20 static const ULWord gHDMIChannelToInputStatusRegNum[] = { kRegHDMIInputStatus1, kRegHDMIInputStatus2, kRegHDMIInputStatus3, kRegHDMIInputStatus4, 0 };
21 static const ULWord gHDMIChannelToControlRegNum[] = { kRegHDMIControl1, kRegHDMIControl2, kRegHDMIControl3, kRegHDMIControl4, 0 };
22 
23 // HDMI V6 multiple output virtual registers:
24 static const ULWord gHDMIChannelToOutControlVRegNum[] = { kVRegHDMIOutControl1, kVRegHDMIOutControl2, kVRegHDMIOutControl3, kVRegHDMIOutControl4,
25  kVRegHDMIOutControl1, kVRegHDMIOutControl1, kVRegHDMIOutControl1, kVRegHDMIOutControl1 };
26 static const ULWord gHDMIChannelToInputStatusVRegNum[] = { kVRegHDMIInputStatus1, kVRegHDMIInputStatus2, kVRegHDMIInputStatus3, kVRegHDMIInputStatus4,
27  kVRegHDMIInputStatus1, kVRegHDMIInputStatus1, kVRegHDMIInputStatus1, kVRegHDMIInputStatus1 };
28 static const ULWord gHDMIChannelToInputControlVRegNum[] = { kVRegHDMIInputControl1, kVRegHDMIInputControl2, kVRegHDMIInputControl3, kVRegHDMIInputControl4,
29  kVRegHDMIInputControl1, kVRegHDMIInputControl1, kVRegHDMIInputControl1, kVRegHDMIInputControl1 };
30 static const ULWord gHDMIChannelToOutStatusVRegNum[] = { kVRegHDMIOutStatus1, kVRegHDMIOutStatus2, kVRegHDMIOutStatus3, kVRegHDMIOutStatus4,
31  kVRegHDMIOutStatus1, kVRegHDMIOutStatus1, kVRegHDMIOutStatus1, kVRegHDMIOutStatus1 };
32 static const ULWord gHDMIChannelToOutHDRGreenPrimaryVRegNum[] = { kVRegHDMIOutHDRGreenPrimary1, kVRegHDMIOutHDRGreenPrimary2, kVRegHDMIOutHDRGreenPrimary3, kVRegHDMIOutHDRGreenPrimary4,
33  kVRegHDMIOutHDRGreenPrimary1, kVRegHDMIOutHDRGreenPrimary1, kVRegHDMIOutHDRGreenPrimary1, kVRegHDMIOutHDRGreenPrimary1 };
34 static const ULWord gHDMIChannelToOutHDRRedPrimaryVRegNum[] = { kVRegHDMIOutHDRRedPrimary1, kVRegHDMIOutHDRRedPrimary2, kVRegHDMIOutHDRRedPrimary3, kVRegHDMIOutHDRRedPrimary4,
35  kVRegHDMIOutHDRRedPrimary1, kVRegHDMIOutHDRRedPrimary1, kVRegHDMIOutHDRRedPrimary1, kVRegHDMIOutHDRRedPrimary1 };
36 static const ULWord gHDMIChannelToOutHDRBluePrimaryVRegNum[] = { kVRegHDMIOutHDRBluePrimary1, kVRegHDMIOutHDRBluePrimary2, kVRegHDMIOutHDRBluePrimary3, kVRegHDMIOutHDRBluePrimary4,
37  kVRegHDMIOutHDRBluePrimary1, kVRegHDMIOutHDRBluePrimary1, kVRegHDMIOutHDRBluePrimary1, kVRegHDMIOutHDRBluePrimary1 };
38 static const ULWord gHDMIChannelToOutHDRWhitePointVRegNum[] = { kVRegHDMIOutHDRWhitePoint1, kVRegHDMIOutHDRWhitePoint2, kVRegHDMIOutHDRWhitePoint3, kVRegHDMIOutHDRWhitePoint4,
39  kVRegHDMIOutHDRWhitePoint1, kVRegHDMIOutHDRWhitePoint1, kVRegHDMIOutHDRWhitePoint1, kVRegHDMIOutHDRWhitePoint1 };
40 static const ULWord gHDMIChannelToOutHDRMasterLuminanceVRegNum[]= { kVRegHDMIOutHDRMasterLuminance1,kVRegHDMIOutHDRMasterLuminance2, kVRegHDMIOutHDRMasterLuminance3, kVRegHDMIOutHDRMasterLuminance4,
41  kVRegHDMIOutHDRMasterLuminance1,kVRegHDMIOutHDRMasterLuminance1, kVRegHDMIOutHDRMasterLuminance1, kVRegHDMIOutHDRMasterLuminance1 };
42 static const ULWord gHDMIChannelToOutHDRLightLevelVRegNum[] = { kVRegHDMIOutHDRLightLevel1, kVRegHDMIOutHDRLightLevel2, kVRegHDMIOutHDRLightLevel3, kVRegHDMIOutHDRLightLevel4,
43  kVRegHDMIOutHDRLightLevel1, kVRegHDMIOutHDRLightLevel1, kVRegHDMIOutHDRLightLevel1, kVRegHDMIOutHDRLightLevel1 };
44 static const ULWord gHDMIChannelToOutHDRControlVRegNum[] = { kVRegHDMIOutHDRControl1, kVRegHDMIOutHDRControl2, kVRegHDMIOutHDRControl3, kVRegHDMIOutHDRControl4,
45  kVRegHDMIOutHDRControl1, kVRegHDMIOutHDRControl1, kVRegHDMIOutHDRControl1, kVRegHDMIOutHDRControl1 };
46 
48 // HDMI
49 
50 // kRegHDMIInputStatus
51 bool CNTV2Card::GetHDMIInputStatusRegNum (ULWord & outRegNum, const NTV2Channel inChannel, const bool in12BitDetection)
52 {
53  const ULWord numInputs (GetNumSupported(kDeviceGetNumHDMIVideoInputs));
54  outRegNum = 0;
55  if (ULWord(inChannel) >= numInputs)
56  return false;
57  if (numInputs == 1)
58  outRegNum = in12BitDetection ? kRegHDMIInputControl : kRegHDMIInputStatus;
59  else
60  outRegNum = in12BitDetection ? gHDMIChannelToControlRegNum[inChannel] : gHDMIChannelToInputStatusRegNum[inChannel];
61  return true;
62 }
63 
64 bool CNTV2Card::GetHDMIInputStatus (ULWord & outValue, const NTV2Channel inChannel, const bool in12BitDetection)
65 {
66  ULWord regNum (0);
67  return GetHDMIInputStatusRegNum(regNum, inChannel, in12BitDetection) && ReadRegister (regNum, outValue);
68 }
69 
70 bool CNTV2Card::GetHDMIInputColor (NTV2LHIHDMIColorSpace & outValue, const NTV2Channel inChannel)
71 {
72  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
73  if (ULWord(inChannel) >= numInputs)
74  return false;
75  return driverInterface().ReadRegister (numInputs == 1 ? ULWord(kRegHDMIInputStatus) : gHDMIChannelToInputStatusRegNum[inChannel],
76  outValue, kLHIRegMaskHDMIInputColorSpace, kLHIRegShiftHDMIInputColorSpace);
77 }
78 
79 bool CNTV2Card::GetHDMIInVideoRange (NTV2HDMIRange & outValue, const NTV2Channel inChannel)
80 {
81  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
82  if (ULWord(inChannel) >= numInputs)
83  return false;
84  return driverInterface().ReadRegister (numInputs == 1 ? ULWord(kRegHDMIInputControl) : gHDMIChannelToControlRegNum[inChannel],
85  outValue, kRegMaskHDMIInfoRange, kRegShiftHDMIInfoRange);
86 }
87 
88 bool CNTV2Card::GetHDMIInDynamicRange (HDRRegValues & outRegValues, const NTV2Channel inChannel)
89 {
90  outRegValues.zero();
91  if (inChannel > NTV2_CHANNEL2)
92  return false;
93 
94  ULWord outValue(0);
95  if (inChannel == NTV2_CHANNEL1)
96  {
97  if (!ReadRegister(kVRegHDMIInDrmInfo1, outValue) || ((outValue & kVRegMaskHDMIInPresent) == 0))
98  return false;
99  outRegValues.electroOpticalTransferFunction = uint8_t((outValue & kVRegMaskHDMIInEOTF) >> kVRegShiftHDMIInEOTF);
100  outRegValues.staticMetadataDescriptorID = uint8_t((outValue & kVRegMaskHDMIInMetadataID) >> kVRegShiftHDMIInMetadataID);
101  ReadRegister(kVRegHDMIInDrmGreenPrimary1, outValue);
102  outRegValues.greenPrimaryX = uint16_t((outValue & kRegMaskHDMIHDRGreenPrimaryX) >> kRegShiftHDMIHDRGreenPrimaryX);
103  outRegValues.greenPrimaryY = uint16_t((outValue & kRegMaskHDMIHDRGreenPrimaryY) >> kRegShiftHDMIHDRGreenPrimaryY);
104  ReadRegister(kVRegHDMIInDrmBluePrimary1, outValue);
105  outRegValues.bluePrimaryX = uint16_t((outValue & kRegMaskHDMIHDRBluePrimaryX) >> kRegShiftHDMIHDRBluePrimaryX);
106  outRegValues.bluePrimaryY = uint16_t((outValue & kRegMaskHDMIHDRBluePrimaryY) >> kRegShiftHDMIHDRBluePrimaryY);
107  ReadRegister(kVRegHDMIInDrmRedPrimary1, outValue);
108  outRegValues.redPrimaryX = uint16_t((outValue & kRegMaskHDMIHDRRedPrimaryX) >> kRegShiftHDMIHDRRedPrimaryX);
109  outRegValues.redPrimaryY = uint16_t((outValue & kRegMaskHDMIHDRRedPrimaryY) >> kRegShiftHDMIHDRRedPrimaryY);
110  ReadRegister(kVRegHDMIInDrmWhitePoint1, outValue);
111  outRegValues.whitePointX = uint16_t((outValue & kRegMaskHDMIHDRWhitePointX) >> kRegShiftHDMIHDRWhitePointX);
112  outRegValues.whitePointY = uint16_t((outValue & kRegMaskHDMIHDRWhitePointY) >> kRegShiftHDMIHDRWhitePointY);
113  ReadRegister(kVRegHDMIInDrmMasteringLuminence1, outValue);
114  outRegValues.maxMasteringLuminance = uint16_t((outValue & kRegMaskHDMIHDRMaxMasteringLuminance) >> kRegShiftHDMIHDRMaxMasteringLuminance);
115  outRegValues.minMasteringLuminance = uint16_t((outValue & kRegMaskHDMIHDRMinMasteringLuminance) >> kRegShiftHDMIHDRMinMasteringLuminance);
116  ReadRegister(kVRegHDMIInDrmLightLevel1, outValue);
117  outRegValues.maxContentLightLevel = uint16_t((outValue & kRegMaskHDMIHDRMaxContentLightLevel) >> kRegShiftHDMIHDRMaxContentLightLevel);
118  outRegValues.maxFrameAverageLightLevel = uint16_t((outValue & kRegMaskHDMIHDRMaxFrameAverageLightLevel) >> kRegShiftHDMIHDRMaxFrameAverageLightLevel);
119  }
120  else if (inChannel == NTV2_CHANNEL2)
121  {
122  if (!ReadRegister(kVRegHDMIInDrmInfo2, outValue) || ((outValue & kVRegMaskHDMIInPresent) == 0))
123  return false;
124  outRegValues.electroOpticalTransferFunction = uint8_t((outValue & kVRegMaskHDMIInEOTF) >> kVRegShiftHDMIInEOTF);
125  outRegValues.staticMetadataDescriptorID = uint8_t((outValue & kVRegMaskHDMIInMetadataID) >> kVRegShiftHDMIInMetadataID);
126  ReadRegister(kVRegHDMIInDrmGreenPrimary2, outValue);
127  outRegValues.greenPrimaryX = uint16_t((outValue & kRegMaskHDMIHDRGreenPrimaryX) >> kRegShiftHDMIHDRGreenPrimaryX);
128  outRegValues.greenPrimaryY = uint16_t((outValue & kRegMaskHDMIHDRGreenPrimaryY) >> kRegShiftHDMIHDRGreenPrimaryY);
129  ReadRegister(kVRegHDMIInDrmBluePrimary2, outValue);
130  outRegValues.bluePrimaryX = uint16_t((outValue & kRegMaskHDMIHDRBluePrimaryX) >> kRegShiftHDMIHDRBluePrimaryX);
131  outRegValues.bluePrimaryY = uint16_t((outValue & kRegMaskHDMIHDRBluePrimaryY) >> kRegShiftHDMIHDRBluePrimaryY);
132  ReadRegister(kVRegHDMIInDrmRedPrimary2, outValue);
133  outRegValues.redPrimaryX = uint16_t((outValue & kRegMaskHDMIHDRRedPrimaryX) >> kRegShiftHDMIHDRRedPrimaryX);
134  outRegValues.redPrimaryY = uint16_t((outValue & kRegMaskHDMIHDRRedPrimaryY) >> kRegShiftHDMIHDRRedPrimaryY);
135  ReadRegister(kVRegHDMIInDrmWhitePoint2, outValue);
136  outRegValues.whitePointX = uint16_t((outValue & kRegMaskHDMIHDRWhitePointX) >> kRegShiftHDMIHDRWhitePointX);
137  outRegValues.whitePointY = uint16_t((outValue & kRegMaskHDMIHDRWhitePointY) >> kRegShiftHDMIHDRWhitePointY);
138  ReadRegister(kVRegHDMIInDrmMasteringLuminence2, outValue);
139  outRegValues.maxMasteringLuminance = uint16_t((outValue & kRegMaskHDMIHDRMaxMasteringLuminance) >> kRegShiftHDMIHDRMaxMasteringLuminance);
140  outRegValues.minMasteringLuminance = uint16_t((outValue & kRegMaskHDMIHDRMinMasteringLuminance) >> kRegShiftHDMIHDRMinMasteringLuminance);
141  ReadRegister(kVRegHDMIInDrmLightLevel2, outValue);
142  outRegValues.maxContentLightLevel = uint16_t((outValue & kRegMaskHDMIHDRMaxContentLightLevel) >> kRegShiftHDMIHDRMaxContentLightLevel);
143  outRegValues.maxFrameAverageLightLevel = uint16_t((outValue & kRegMaskHDMIHDRMaxFrameAverageLightLevel) >> kRegShiftHDMIHDRMaxFrameAverageLightLevel);
144  }
145  return true;
146 }
147 
148 bool CNTV2Card::GetHDMIInDynamicRange (HDRFloatValues & outFloatValues, const NTV2Channel inChannel)
149 {
150  HDRRegValues regValues;
151  outFloatValues.zero();
152  if (!GetHDMIInDynamicRange(regValues, inChannel))
153  return false;
154  return outFloatValues.setFromRegValues(regValues);
155 }
156 
157 bool CNTV2Card::GetHDMIInColorimetry (NTV2HDMIColorimetry & outColorimetry, const NTV2Channel inChannel)
158 {
159  outColorimetry = NTV2_HDMIColorimetryNoData;
160  if (inChannel > NTV2_CHANNEL2)
161  return false;
162  return CNTV2DriverInterface::ReadRegister (inChannel == NTV2_CHANNEL1 ? kVRegHDMIInAviInfo1 : kVRegHDMIInAviInfo2,
163  outColorimetry, kVRegMaskHDMIInColorimetry, kVRegShiftHDMIInColorimetry);
164 }
165 
166 bool CNTV2Card::GetHDMIInDolbyVision (bool & outIsDolbyVision, const NTV2Channel inChannel)
167 {
168  outIsDolbyVision = false;
169  if (inChannel > NTV2_CHANNEL2)
170  return false;
171  return CNTV2DriverInterface::ReadRegister (inChannel == NTV2_CHANNEL1 ? kVRegHDMIInAviInfo1 : kVRegHDMIInAviInfo2,
172  outIsDolbyVision, kVRegMaskHDMIInDolbyVision, kVRegShiftHDMIInDolbyVision);
173 }
174 
175 // kRegHDMIInputControl
176 bool CNTV2Card::SetHDMIInputRange (const NTV2HDMIRange inValue, const NTV2Channel inChannel)
177 {
178  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
179  if (numInputs < 1)
180  return false;
181  return inChannel == NTV2_CHANNEL1 // FIX THIS! MrBill
182  && WriteRegister (kRegHDMIInputControl, ULWord(inValue), kRegMaskHDMIInputRange, kRegShiftHDMIInputRange);
183 }
184 
185 bool CNTV2Card::GetHDMIInputRange (NTV2HDMIRange & outValue, const NTV2Channel inChannel)
186 {
187  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
188  if (numInputs < 1)
189  return false;
190  return inChannel == NTV2_CHANNEL1 // FIX THIS! MrBill
191  && CNTV2DriverInterface::ReadRegister(kRegHDMIInputControl, outValue, kRegMaskHDMIInputRange, kRegShiftHDMIInputRange);
192 }
193 
194 bool CNTV2Card::SetHDMIInColorSpace (const NTV2HDMIColorSpace inValue, const NTV2Channel inChannel)
195 {
196  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
197  if (numInputs < 1)
198  return false;
199  return inChannel == NTV2_CHANNEL1 // FIX THIS! MrBill
200  && WriteRegister (kRegHDMIInputControl, ULWord(inValue), kRegMaskHDMIColorSpace, kRegShiftHDMIColorSpace);
201 }
202 
203 bool CNTV2Card::GetHDMIInColorSpace (NTV2HDMIColorSpace & outValue, const NTV2Channel inChannel)
204 {
205  const ULWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
206  if (numInputs < 1)
207  return false;
208  return inChannel == NTV2_CHANNEL1 // FIX THIS! MrBill
209  && CNTV2DriverInterface::ReadRegister (kRegHDMIInputControl, outValue, kRegMaskHDMIColorSpace, kRegShiftHDMIColorSpace);
210 }
211 
212 bool CNTV2Card::SetHDMIInBitDepth (const NTV2HDMIBitDepth inNewValue, const NTV2Channel inChannel)
213 {
214  const UWord numInputs(GetNumSupported(kDeviceGetNumHDMIVideoInputs));
215  if (numInputs < 1)
216  return false;
217  if (numInputs <= UWord(inChannel))
218  return false;
219  if (NTV2_IS_VALID_HDMI_BITDEPTH(inNewValue))
220  return false;
221  // FINISH THIS MrBill
222  return true;
223 }
224 
225 bool CNTV2Card::GetHDMIInBitDepth (NTV2HDMIBitDepth & outValue, const NTV2Channel inChannel)
226 {
227  outValue = NTV2_INVALID_HDMIBitDepth;
228  ULWord status(0), maskVal, shiftVal;
229  bool isV2(GetNumSupported(kDeviceGetHDMIVersion) >= 2);
230  maskVal = isV2 ? kRegMaskHDMIInColorDepth : kLHIRegMaskHDMIInputBitDepth;
231  shiftVal = isV2 ? kRegShiftHDMIInColorDepth : kLHIRegShiftHDMIInputBitDepth;
232  if (!GetHDMIInputStatus(status, inChannel, isV2))
233  return false;
234  outValue = NTV2HDMIBitDepth((status & maskVal) >> shiftVal);
235  return NTV2_IS_VALID_HDMI_BITDEPTH(outValue);
236 }
237 
238 bool CNTV2Card::GetHDMIInProtocol (NTV2HDMIProtocol & outValue, const NTV2Channel inChannel)
239 {
240  outValue = NTV2_INVALID_HDMI_PROTOCOL;
241  ULWord status(0);
242  if (!GetHDMIInputStatus(status, inChannel))
243  return false;
244  outValue = NTV2HDMIProtocol((status & kLHIRegMaskHDMIInputProtocol) >> kLHIRegShiftHDMIInputProtocol);
245  return NTV2_IS_VALID_HDMI_PROTOCOL(outValue);
246 }
247 
248 bool CNTV2Card::GetHDMIInIsLocked (bool & outIsLocked, const NTV2Channel inChannel)
249 {
250  outIsLocked = false;
251  ULWord status(0);
252  if (!GetHDMIInputStatus(status, inChannel))
253  return false;
254  if (GetDeviceID() == DEVICE_ID_KONALHIDVI)
255  outIsLocked = (status & (BIT(0) | BIT(1))) == (BIT(0) | BIT(1));
256  else
257  outIsLocked = (status & kRegMaskInputStatusLock) ? true : false;
258  return true;
259 }
260 
261 bool CNTV2Card::SetHDMIInAudioSampleRateConverterEnable (const bool value, const NTV2Channel inChannel)
262 {
263  const ULWord tempVal (!value); // this is high to disable sample rate conversion
264  return inChannel == NTV2_CHANNEL1 // FIX THIS MrBill
265  && WriteRegister (kRegHDMIInputControl, tempVal, kRegMaskHDMISampleRateConverterEnable, kRegShiftHDMISampleRateConverterEnable);
266 }
267 
268 
269 bool CNTV2Card::GetHDMIInAudioSampleRateConverterEnable (bool & outEnabled, const NTV2Channel inChannel)
270 {
271  if (inChannel != NTV2_CHANNEL1)
272  return false; // FIX THIS MrBill
273  bool result(driverInterface().ReadRegister (kRegHDMIInputControl, outEnabled, kRegMaskHDMISampleRateConverterEnable, kRegShiftHDMISampleRateConverterEnable));
274  if (result)
275  outEnabled = !outEnabled; // this is high to disable sample rate conversion
276  return result;
277 }
278 
279 
280 bool CNTV2Card::GetHDMIInputAudioChannels (NTV2HDMIAudioChannels & outValue, const NTV2Channel inChannel)
281 {
282  if (inChannel != NTV2_CHANNEL1)
283  return false; // FIX THIS MrBill
284  ULWord tempVal (0);
285  outValue = NTV2_INVALID_HDMI_AUDIO_CHANNELS;
286  if (!ReadRegister(kRegHDMIInputStatus, tempVal))
287  return false;
288  outValue = (tempVal & kLHIRegMaskHDMIInput2ChAudio) ? NTV2_HDMIAudio2Channels : NTV2_HDMIAudio8Channels;
289  return true;
290 }
291 
292 static const ULWord gKonaHDMICtrlRegs[] = {0x1d16, 0x2516, 0x2c14, 0x3014}; // KonaHDMI only
293 
294 bool CNTV2Card::GetHDMIInAudioChannel34Swap (bool & outIsSwapped, const NTV2Channel inChannel)
295 {
296  outIsSwapped = false;
297  if (GetIndexForNTV2Channel(inChannel) >= GetNumSupported(kDeviceGetNumHDMIVideoInputs))
298  return false; // No such HDMI input
299  if (_boardID == DEVICE_ID_KONAHDMI)
300  return CNTV2DriverInterface::ReadRegister(gKonaHDMICtrlRegs[inChannel], outIsSwapped, kRegMaskHDMISwapInputAudCh34, kRegShiftHDMISwapInputAudCh34); // TBD
301  return CNTV2DriverInterface::ReadRegister(kRegHDMIInputControl, outIsSwapped, kRegMaskHDMISwapInputAudCh34, kRegShiftHDMISwapInputAudCh34);
302 }
303 
304 bool CNTV2Card::SetHDMIInAudioChannel34Swap (const bool inIsSwapped, const NTV2Channel inChannel)
305 {
306  if (GetIndexForNTV2Channel(inChannel) >= GetNumSupported(kDeviceGetNumHDMIVideoInputs))
307  return false; // No such HDMI input
308  if (_boardID == DEVICE_ID_KONAHDMI)
309  return WriteRegister(gKonaHDMICtrlRegs[inChannel], inIsSwapped ? 1 : 0, kRegMaskHDMISwapInputAudCh34, kRegShiftHDMISwapInputAudCh34); // TBD
310  return WriteRegister(kRegHDMIInputControl, inIsSwapped ? 1 : 0, kRegMaskHDMISwapInputAudCh34, kRegShiftHDMISwapInputAudCh34);
311 }
312 
313 // kRegHDMIOut3DControl
314 bool CNTV2Card::SetHDMIOut3DPresent (const bool value)
315 {
316  return GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
317  && WriteRegister (kRegHDMIOut3DControl, ULWord(value), kRegMaskHDMIOut3DPresent, kRegShiftHDMIOut3DPresent);
318 }
319 
320 bool CNTV2Card::GetHDMIOut3DPresent (bool & outValue)
321 {
322  return GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
323  && CNTV2DriverInterface::ReadRegister (kRegHDMIOut3DControl, outValue, kRegMaskHDMIOut3DPresent, kRegShiftHDMIOut3DPresent);
324 }
325 
326 bool CNTV2Card::SetHDMIOut3DMode (const NTV2HDMIOut3DMode inValue)
327 {
328  return GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
329  && WriteRegister (kRegHDMIOut3DControl, ULWord(inValue), kRegMaskHDMIOut3DMode, kRegShiftHDMIOut3DMode);
330 }
331 
332 bool CNTV2Card::GetHDMIOut3DMode (NTV2HDMIOut3DMode & outValue)
333 {
334  return GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
335  && CNTV2DriverInterface::ReadRegister (kRegHDMIOut3DControl, outValue, kRegMaskHDMIOut3DMode, kRegShiftHDMIOut3DMode);
336 }
337 
338 // kRegHDMIOutControl
339 bool CNTV2Card::SetHDMIOutVideoStandard (const NTV2Standard inValue, const NTV2Channel inWhichHDMIOut)
340 {
341  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
342  ULWord reg (kRegHDMIOutControl);
343 
344  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
345  return false;
346  return WriteRegister (reg, ULWord(inValue), hdmiVers == 1 ? kRegMaskHDMIOutVideoStd : kRegMaskHDMIOutV2VideoStd, kRegShiftHDMIOutVideoStd);
347 }
348 
349 bool CNTV2Card::GetHDMIOutVideoStandard (NTV2Standard & outValue, const NTV2Channel inWhichHDMIOut)
350 {
351  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
352  ULWord reg (kRegHDMIOutControl);
353 
354  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
355  {
356  outValue = NTV2_STANDARD_INVALID;
357  return false;
358  }
359  return CNTV2DriverInterface::ReadRegister (reg, outValue, hdmiVers == 1 ? kRegMaskHDMIOutVideoStd : kRegMaskHDMIOutV2VideoStd, kRegShiftHDMIOutVideoStd);
360 }
361 
362 bool CNTV2Card::SetHDMIV2TxBypass (const bool bypass)
363 {
364  return GetNumSupported(kDeviceGetNumHDMIVideoOutputs)
365  && WriteRegister (kRegHDMIOutControl, bypass, kRegMaskHDMIV2TxBypass, kRegShiftHDMIV2TxBypass);
366 }
367 
368 bool CNTV2Card::SetHDMIOutSampleStructure (const NTV2HDMISampleStructure inValue, const NTV2Channel inWhichHDMIOut)
369 {
370  ULWord reg (kRegHDMIOutControl);
371 
372  if (!NTV2_IS_VALID_HDMI_SAMPLE_STRUCT(inValue))
373  return false;
374  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
375  return false;
376  return WriteRegister (reg, ULWord(inValue), kRegMaskHDMISampling, kRegShiftHDMISampling);
377 }
378 
379 bool CNTV2Card::GetHDMIOutSampleStructure (NTV2HDMISampleStructure & outValue, const NTV2Channel inWhichHDMIOut)
380 {
381  ULWord reg (kRegHDMIOutControl);
382 
383  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
384  return false;
385  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMISampling, kRegShiftHDMISampling);
386 }
387 
388 bool CNTV2Card::SetHDMIOutVideoFPS (const NTV2FrameRate value, const NTV2Channel inWhichHDMIOut)
389 {
390  ULWord reg (kRegHDMIOutControl);
391 
392  if (!NTV2_IS_VALID_NTV2FrameRate(value))
393  return false;
394  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
395  return false;
396  return WriteRegister (reg, ULWord(value), kLHIRegMaskHDMIOutFPS, kLHIRegShiftHDMIOutFPS);
397 }
398 
399 bool CNTV2Card::GetHDMIOutVideoFPS (NTV2FrameRate & outValue, const NTV2Channel inWhichHDMIOut)
400 {
401  ULWord reg (kRegHDMIOutControl);
402 
403  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
404  return false;
405  return CNTV2DriverInterface::ReadRegister (reg, outValue, kLHIRegMaskHDMIOutFPS, kLHIRegShiftHDMIOutFPS);
406 }
407 
408 bool CNTV2Card::SetHDMIOutRange (const NTV2HDMIRange value, const NTV2Channel inWhichHDMIOut)
409 {
410  ULWord reg (kRegHDMIOutControl);
411  if (!NTV2_IS_VALID_HDMI_RANGE(value))
412  return false;
413  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
414  return false;
415  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutRange, kRegShiftHDMIOutRange);
416 }
417 
418 bool CNTV2Card::GetHDMIOutRange (NTV2HDMIRange & outValue, const NTV2Channel inWhichHDMIOut)
419 {
420  ULWord reg (kRegHDMIOutControl);
421  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
422  return false;
423  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutRange, kRegShiftHDMIOutRange);
424 }
425 
426 
427 
428 bool CNTV2Card::SetHDMIOutColorSpace (const NTV2HDMIColorSpace inValue, const NTV2Channel inWhichHDMIOut)
429 { // Register 125 This function used to touch bits 4 & 5 (from the old FS/1 days) --- now obsolete.
430  //return WriteRegister (kRegHDMIOutControl, ULWord(value), kRegMaskHDMIColorSpace, kRegShiftHDMIColorSpace);
431  // Fixed in SDK 14.1 to work with modern NTV2 devices, but using the old NTV2HDMIColorSpace enum:
432 
433  ULWord reg (kRegHDMIOutControl);
434  ULWord newCorrectValue (0);
435 
436  switch (inValue)
437  {
438  case NTV2_HDMIColorSpaceRGB: newCorrectValue = NTV2_LHIHDMIColorSpaceRGB; break;
439  case NTV2_HDMIColorSpaceYCbCr: newCorrectValue = NTV2_LHIHDMIColorSpaceYCbCr; break;
440  default: return false; // Illegal value
441  }
442 
443  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
444  return false;
445 
446  // Register 125 Bit 8
447  return WriteRegister (reg, newCorrectValue, kLHIRegMaskHDMIOutColorSpace, kLHIRegShiftHDMIOutColorSpace);
448 }
449 
450 bool CNTV2Card::GetHDMIOutColorSpace (NTV2HDMIColorSpace & outValue, const NTV2Channel inWhichHDMIOut)
451 { // Register 125 This function used to read bits 4 & 5 (from the old FS/1 days) --- now obsolete.
452  //return ReadRegister (kRegHDMIOutControl, outValue, kRegMaskHDMIColorSpace, kRegShiftHDMIColorSpace);
453  // Fixed in SDK 14.1 to work with modern NTV2 devices, but using the old NTV2HDMIColorSpace enum:
454 
455  ULWord reg (kRegHDMIOutControl);
456  ULWord correctValue (0);
457 
458  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
459  return false;
460 
461  // Register 125 Bit 8
462  if (!ReadRegister (reg, correctValue, kLHIRegMaskHDMIOutColorSpace, kLHIRegShiftHDMIOutColorSpace))
463  return false; // Fail
464 
465  switch(correctValue)
466  {
467  case NTV2_LHIHDMIColorSpaceYCbCr: outValue = NTV2_HDMIColorSpaceYCbCr; break;
468  case NTV2_LHIHDMIColorSpaceRGB: outValue = NTV2_HDMIColorSpaceRGB; break;
469  default: return false; // Bad value?!
470  }
471  return true;
472 }
473 
474 
475 bool CNTV2Card::SetLHIHDMIOutColorSpace (NTV2LHIHDMIColorSpace value, const NTV2Channel inWhichHDMIOut)
476 { // Register 125 Bit 8
477  ULWord reg (kRegHDMIOutControl);
478  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
479  return false;
480  return WriteRegister (reg, ULWord(value), kLHIRegMaskHDMIOutColorSpace, kLHIRegShiftHDMIOutColorSpace);
481 }
482 
483 bool CNTV2Card::GetLHIHDMIOutColorSpace (NTV2LHIHDMIColorSpace & outValue, const NTV2Channel inWhichHDMIOut)
484 { // Register 125 Bit 8
485  ULWord reg(kRegHDMIOutControl), value(0);
486  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
487  return false;
488  bool result (ReadRegister (reg, value, kLHIRegMaskHDMIOutColorSpace, kLHIRegShiftHDMIOutColorSpace));
489  outValue = NTV2LHIHDMIColorSpace(value);
490  return result;
491 }
492 
493 
494 
495 bool CNTV2Card::GetHDMIOutDownstreamBitDepth (NTV2HDMIBitDepth & outValue, const NTV2Channel inWhichHDMIOut)
496 {
497  ULWord reg(kRegHDMIInputStatus);
498  if (!GetHDMIOutInputStatusRegNum(reg, inWhichHDMIOut))
499  return false;
500  return CNTV2DriverInterface::ReadRegister (reg, outValue, kLHIRegMaskHDMIOutputEDID10Bit, kLHIRegShiftHDMIOutputEDID10Bit);
501 }
502 
503 bool CNTV2Card::GetHDMIOutDownstreamColorSpace (NTV2LHIHDMIColorSpace & outValue, const NTV2Channel inWhichHDMIOut)
504 {
505  ULWord reg(kRegHDMIInputStatus);
506  if (!GetHDMIOutInputStatusRegNum(reg, inWhichHDMIOut))
507  return false;
508  return CNTV2DriverInterface::ReadRegister (reg, outValue, kLHIRegMaskHDMIOutputEDIDRGB, kLHIRegShiftHDMIOutputEDIDRGB);
509 }
510 
511 bool CNTV2Card::SetHDMIOutBitDepth (const NTV2HDMIBitDepth value, const NTV2Channel inWhichHDMIOut)
512 {
513  ULWord regOC(kRegHDMIOutControl);
514  ULWord regIC(kRegHDMIInputControl);
515  bool ret = true;
516 
517  if (!NTV2_IS_VALID_HDMI_BITDEPTH(value))
518  return false;
519  if (!GetHDMIOutControlReg(regOC, inWhichHDMIOut))
520  return false;
521  if (!GetHDMIOutInputControlRegNum(regIC, inWhichHDMIOut))
522  return false;
523  if (value == NTV2_HDMI12Bit)
524  {
525  ret &= WriteRegister (regOC, 0, kLHIRegMaskHDMIOutBitDepth, kLHIRegShiftHDMIOutBitDepth);
526  ret &= WriteRegister (regOC, 2, kRegMaskHDMIVOBD, kRegShiftHDMIVOBD);
527  ret &= WriteRegister (regIC, 1, kRegMaskHDMIOut12Bit, kRegShiftHDMIOut12Bit);
528  }
529  else if (value == NTV2_HDMI10Bit)
530  {
531  ret &= WriteRegister (regOC, 1, kLHIRegMaskHDMIOutBitDepth, kLHIRegShiftHDMIOutBitDepth);
532  ret &= WriteRegister (regOC, 0, kRegMaskHDMIVOBD, kRegShiftHDMIVOBD);
533  ret &= WriteRegister (regIC, 0, kRegMaskHDMIOut12Bit, kRegShiftHDMIOut12Bit);
534  }
535  else
536  {
537  ret &= WriteRegister (regOC, 0, kLHIRegMaskHDMIOutBitDepth, kLHIRegShiftHDMIOutBitDepth);
538  ret &= WriteRegister (regOC, 0, kRegMaskHDMIVOBD, kRegShiftHDMIVOBD);
539  ret &= WriteRegister (regIC, 0, kRegMaskHDMIOut12Bit, kRegShiftHDMIOut12Bit);
540  }
541  return ret;
542 }
543 
544 bool CNTV2Card::GetHDMIOutBitDepth (NTV2HDMIBitDepth & outValue, const NTV2Channel inWhichHDMIOut)
545 {
546  ULWord regOC(kRegHDMIOutControl);
547  ULWord regIC(kRegHDMIInputControl);
548  ULWord d10(0), d12(0);
549 
550  outValue = NTV2_INVALID_HDMIBitDepth;
551 
552  if (!GetHDMIOutControlReg(regOC, inWhichHDMIOut))
553  return false;
554  if (!GetHDMIOutInputControlRegNum(regIC, inWhichHDMIOut))
555  return false;
556  if (!(ReadRegister(regOC, d10, kLHIRegMaskHDMIOutBitDepth, kLHIRegShiftHDMIOutBitDepth)
557  && ReadRegister (regIC, d12, kRegMaskHDMIOut12Bit, kRegShiftHDMIOut12Bit)))
558  return false;
559 
560  if (d12 > 0)
561  outValue = NTV2_HDMI12Bit;
562  else if (d10 > 0)
563  outValue = NTV2_HDMI10Bit;
564  else
565  outValue = NTV2_HDMI8Bit;
566  return true;
567 }
568 
569 bool CNTV2Card::SetHDMIOutProtocol (const NTV2HDMIProtocol value, const NTV2Channel inWhichHDMIOut)
570 {
571  ULWord reg(kRegHDMIOutControl);
572  if (!NTV2_IS_VALID_HDMI_PROTOCOL(value))
573  return false;
574  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
575  return false;
576  return WriteRegister (reg, ULWord(value), kLHIRegMaskHDMIOutDVI, kLHIRegShiftHDMIOutDVI);
577 }
578 
579 bool CNTV2Card::GetHDMIOutProtocol (NTV2HDMIProtocol & outValue, const NTV2Channel inWhichHDMIOut)
580 {
581  ULWord reg(kRegHDMIOutControl);
582  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
583  return false;
584  return CNTV2DriverInterface::ReadRegister (reg, outValue, kLHIRegMaskHDMIOutDVI, kLHIRegShiftHDMIOutDVI);
585 }
586 
587 bool CNTV2Card::SetHDMIOutForceConfig (const bool value, const NTV2Channel inWhichHDMIOut)
588 {
589  ULWord reg(kRegHDMIOutControl);
590  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
591  return false;
592  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
593 }
594 
595 bool CNTV2Card::GetHDMIOutForceConfig (bool & outValue, const NTV2Channel inWhichHDMIOut)
596 {
597  ULWord reg(kRegHDMIOutControl);
598  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
599  return false;
600  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
601 }
602 
603 bool CNTV2Card::SetHDMIOutDisable (const bool value, const NTV2Channel inWhichHDMIOut)
604 {
605  ULWord reg(kRegHDMIOutControl);
606  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
607  return false;
608  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutDisable, kRegShiftHDMIOutDisable);
609 }
610 
611 bool CNTV2Card::GetHDMIOutDisable (bool & outValue, const NTV2Channel inWhichHDMIOut)
612 {
613  ULWord reg(kRegHDMIOutControl);
614  if (!GetHDMIOutControlReg(reg, inWhichHDMIOut))
615  return false;
616  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutDisable, kRegShiftHDMIOutDisable);
617 }
618 
619 bool CNTV2Card::SetHDMIOutPrefer420 (const bool value, const NTV2Channel inWhichHDMIOut)
620 {
621  ULWord reg(kRegHDMIInputControl);
622  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
623  return false;
624  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutPrefer420, kRegShiftHDMIOutPrefer420);
625 }
626 
627 bool CNTV2Card::GetHDMIOutPrefer420 (bool & outValue, const NTV2Channel inWhichHDMIOut)
628 {
629  ULWord reg(kRegHDMIInputControl);
630  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
631  return false;
632  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutPrefer420, kRegShiftHDMIOutPrefer420);
633 }
634 
635 bool CNTV2Card::SetHDMIOutForceYUV (const bool value, const NTV2Channel inWhichHDMIOut)
636 {
637  ULWord reg(kRegHDMIInputControl);
638  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
639  return false;
640  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutForceYUV, kRegShiftHDMIOutForceYUV);
641 }
642 
643 bool CNTV2Card::GetHDMIOutForceYUV (bool & outValue, const NTV2Channel inWhichHDMIOut)
644 {
645  ULWord reg(kRegHDMIInputControl);
646  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
647  return false;
648  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutForceYUV, kRegShiftHDMIOutForceYUV);
649 }
650 
651 bool CNTV2Card::SetHDMIOutForceRGB (const bool value, const NTV2Channel inWhichHDMIOut)
652 {
653  ULWord reg(kRegHDMIInputControl);
654  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
655  return false;
656  return WriteRegister (reg, ULWord(value), kRegMaskHDMIOutForceRGB, kRegShiftHDMIOutForceRGB);
657 }
658 
659 bool CNTV2Card::GetHDMIOutForceRGB (bool & outValue, const NTV2Channel inWhichHDMIOut)
660 {
661  ULWord reg(kRegHDMIInputControl);
662  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
663  return false;
664  return CNTV2DriverInterface::ReadRegister (reg, outValue, kRegMaskHDMIOutForceRGB, kRegShiftHDMIOutForceRGB);
665 }
666 
667 bool CNTV2Card::SetHDMIOutDecimateMode (const bool inIsEnabled)
668 {
669  return GetNumSupported(kDeviceGetHDMIVersion) > 1
670  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
671  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskRasterDecimate, kRegShiftRasterDecimate);
672 }
673 
674 bool CNTV2Card::GetHDMIOutDecimateMode(bool & outIsEnabled)
675 {
676  return GetNumSupported(kDeviceGetHDMIVersion) > 1
677  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
678  && CNTV2DriverInterface::ReadRegister (kRegRasterizerControl, outIsEnabled, kRegMaskRasterDecimate, kRegShiftRasterDecimate);
679 }
680 
681 bool CNTV2Card::SetHDMIOutTsiIO (const bool inIsEnabled)
682 {
683  return GetNumSupported(kDeviceGetHDMIVersion) > 1
684  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
685  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskTsiIO, kRegShiftTsiIO);
686 }
687 
688 bool CNTV2Card::GetHDMIOutTsiIO (bool & outIsEnabled)
689 {
690  return GetNumSupported(kDeviceGetHDMIVersion) > 1
691  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
692  && CNTV2DriverInterface::ReadRegister(kRegRasterizerControl, outIsEnabled, kRegMaskTsiIO, kRegShiftTsiIO);
693 }
694 
695 bool CNTV2Card::SetHDMIOutLevelBMode (const bool inIsEnabled)
696 {
697  return GetNumSupported(kDeviceGetHDMIVersion) > 1
698  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
699  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskRasterLevelB, kRegShiftRasterLevelB);
700 }
701 
702 bool CNTV2Card::GetHDMIOutLevelBMode (bool & outIsEnabled)
703 {
704  return GetNumSupported(kDeviceGetHDMIVersion) > 1
705  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
706  && CNTV2DriverInterface::ReadRegister (kRegRasterizerControl, outIsEnabled, kRegMaskRasterLevelB, kRegShiftRasterLevelB);
707 }
708 
709 bool CNTV2Card::SetHDMIV2Mode (const NTV2HDMIV2Mode inMode)
710 {
711  return GetNumSupported(kDeviceGetHDMIVersion) > 1
712  && WriteRegister(kRegRasterizerControl, inMode, kRegMaskRasterMode, kRegShiftRasterMode);
713 }
714 
715 
716 bool CNTV2Card::GetHDMIV2Mode (NTV2HDMIV2Mode & outMode)
717 {
718  return GetNumSupported(kDeviceGetHDMIVersion) > 1
719  && CNTV2DriverInterface::ReadRegister(kRegRasterizerControl, outMode, kRegMaskRasterMode, kRegShiftRasterMode);
720 }
721 
722 
723 bool CNTV2Card::GetHDMIOutStatus (NTV2HDMIOutputStatus & outStatus, const NTV2Channel inWhichHDMIOut)
724 {
725  ULWord reg(kVRegHDMIOutStatus1), data(0);
726  outStatus.Clear();
727  if (GetNumSupported(kDeviceGetHDMIVersion) < 4)
728  return false; // must have HDMI version 4 or higher
729  if (!GetHDMIOutStatusReg(reg, inWhichHDMIOut))
730  return false;
731  if (!ReadRegister(reg, data))
732  return false; // ReadRegister failed
733  return outStatus.SetFromRegValue(data);
734 }
735 
736 
737 bool CNTV2Card::SetHDMIHDRGreenPrimaryX(const uint16_t inGreenPrimaryX, const NTV2Channel inWhichHDMIOut)
738 {
739  ULWord reg(kRegHDMIHDRGreenPrimary);
740  if(!NTV2_IS_VALID_HDR_PRIMARY(inGreenPrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
741  return false;
742  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrGreenXCh1, uint32_t(inGreenPrimaryX)))
743  return false;
744  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
745  return false;
746  return WriteRegister(reg, uint32_t(inGreenPrimaryX), kRegMaskHDMIHDRGreenPrimaryX, kRegShiftHDMIHDRGreenPrimaryX);
747 }
748 
749 bool CNTV2Card::GetHDMIHDRGreenPrimaryX(uint16_t & outGreenPrimaryX, const NTV2Channel inWhichHDMIOut)
750 {
751  ULWord reg(kRegHDMIHDRGreenPrimary);
752  if (!IsSupported(kDeviceCanDoHDMIHDROut))
753  return false;
754  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
755  return false;
756  return CNTV2DriverInterface::ReadRegister(reg, outGreenPrimaryX, kRegMaskHDMIHDRGreenPrimaryX, kRegShiftHDMIHDRGreenPrimaryX);
757 }
758 
759 bool CNTV2Card::SetHDMIHDRGreenPrimaryY(const uint16_t inGreenPrimaryY, const NTV2Channel inWhichHDMIOut)
760 {
761  ULWord reg(kRegHDMIHDRGreenPrimary);
762  if (!NTV2_IS_VALID_HDR_PRIMARY(inGreenPrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
763  return false;
764  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrGreenYCh1, uint32_t(inGreenPrimaryY)))
765  return false;
766  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
767  return false;
768  return WriteRegister(reg, uint32_t(inGreenPrimaryY), kRegMaskHDMIHDRGreenPrimaryY, kRegShiftHDMIHDRGreenPrimaryY);
769 }
770 
771 bool CNTV2Card::GetHDMIHDRGreenPrimaryY(uint16_t & outGreenPrimaryY, const NTV2Channel inWhichHDMIOut)
772 {
773  ULWord reg(kRegHDMIHDRGreenPrimary);
774  if (!IsSupported(kDeviceCanDoHDMIHDROut))
775  return false;
776  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
777  return false;
778  return CNTV2DriverInterface::ReadRegister(reg, outGreenPrimaryY, kRegMaskHDMIHDRGreenPrimaryY, kRegShiftHDMIHDRGreenPrimaryY);
779 }
780 
781 bool CNTV2Card::SetHDMIHDRBluePrimaryX(const uint16_t inBluePrimaryX, const NTV2Channel inWhichHDMIOut)
782 {
783  ULWord reg(kRegHDMIHDRBluePrimary);
784  if (!NTV2_IS_VALID_HDR_PRIMARY(inBluePrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
785  return false;
786  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrBlueXCh1, uint32_t(inBluePrimaryX)))
787  return false;
788  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
789  return false;
790  return WriteRegister(reg, uint32_t(inBluePrimaryX), kRegMaskHDMIHDRBluePrimaryX, kRegShiftHDMIHDRBluePrimaryX);
791 }
792 
793 bool CNTV2Card::GetHDMIHDRBluePrimaryX(uint16_t & outBluePrimaryX, const NTV2Channel inWhichHDMIOut)
794 {
795  ULWord reg(kRegHDMIHDRBluePrimary);
796  if (!IsSupported(kDeviceCanDoHDMIHDROut))
797  return false;
798  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
799  return false;
800  return CNTV2DriverInterface::ReadRegister(reg, outBluePrimaryX, kRegMaskHDMIHDRBluePrimaryX, kRegShiftHDMIHDRBluePrimaryX);
801 }
802 
803 bool CNTV2Card::SetHDMIHDRBluePrimaryY(const uint16_t inBluePrimaryY, const NTV2Channel inWhichHDMIOut)
804 {
805  ULWord reg(kRegHDMIHDRBluePrimary);
806  if (!NTV2_IS_VALID_HDR_PRIMARY(inBluePrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
807  return false;
808  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrBlueYCh1, uint32_t(inBluePrimaryY)))
809  return false;
810  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
811  return false;
812  return WriteRegister(reg, uint32_t(inBluePrimaryY), kRegMaskHDMIHDRBluePrimaryY, kRegShiftHDMIHDRBluePrimaryY);
813 }
814 
815 bool CNTV2Card::GetHDMIHDRBluePrimaryY(uint16_t & outBluePrimaryY, const NTV2Channel inWhichHDMIOut)
816 {
817  ULWord reg(kRegHDMIHDRBluePrimary);
818  if (!IsSupported(kDeviceCanDoHDMIHDROut))
819  return false;
820  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
821  return false;
822  return CNTV2DriverInterface::ReadRegister(reg, outBluePrimaryY, kRegMaskHDMIHDRBluePrimaryY, kRegShiftHDMIHDRBluePrimaryY);
823 }
824 
825 bool CNTV2Card::SetHDMIHDRRedPrimaryX(const uint16_t inRedPrimaryX, const NTV2Channel inWhichHDMIOut)
826 {
827  ULWord reg(kRegHDMIHDRRedPrimary);
828  if (!NTV2_IS_VALID_HDR_PRIMARY(inRedPrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
829  return false;
830  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrRedXCh1, uint32_t(inRedPrimaryX)))
831  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
832  return false;
833  return WriteRegister(reg, uint32_t(inRedPrimaryX), kRegMaskHDMIHDRRedPrimaryX, kRegShiftHDMIHDRRedPrimaryX);
834 }
835 
836 bool CNTV2Card::GetHDMIHDRRedPrimaryX(uint16_t & outRedPrimaryX, const NTV2Channel inWhichHDMIOut)
837 {
838  ULWord reg(kRegHDMIHDRRedPrimary);
839  if (!IsSupported(kDeviceCanDoHDMIHDROut))
840  return false;
841  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
842  return false;
843  return CNTV2DriverInterface::ReadRegister(reg, outRedPrimaryX, kRegMaskHDMIHDRRedPrimaryX, kRegShiftHDMIHDRRedPrimaryX);
844 }
845 
846 bool CNTV2Card::SetHDMIHDRRedPrimaryY(const uint16_t inRedPrimaryY, const NTV2Channel inWhichHDMIOut)
847 {
848  ULWord reg(kRegHDMIHDRRedPrimary);
849  if (!NTV2_IS_VALID_HDR_PRIMARY(inRedPrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
850  return false;
851  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrRedYCh1, uint32_t(inRedPrimaryY)))
852  return false;
853  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
854  return false;
855  return WriteRegister(reg, uint32_t(inRedPrimaryY), kRegMaskHDMIHDRRedPrimaryY, kRegShiftHDMIHDRRedPrimaryY);
856 }
857 
858 bool CNTV2Card::GetHDMIHDRRedPrimaryY(uint16_t & outRedPrimaryY, const NTV2Channel inWhichHDMIOut)
859 {
860  ULWord reg(kRegHDMIHDRRedPrimary);
861  if (!IsSupported(kDeviceCanDoHDMIHDROut))
862  return false;
863  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
864  return false;
865  return CNTV2DriverInterface::ReadRegister(reg, outRedPrimaryY, kRegMaskHDMIHDRRedPrimaryY, kRegShiftHDMIHDRRedPrimaryY);
866 }
867 
868 bool CNTV2Card::SetHDMIHDRWhitePointX(const uint16_t inWhitePointX, const NTV2Channel inWhichHDMIOut)
869 {
870  ULWord reg(kRegHDMIHDRWhitePoint);
871  if (!NTV2_IS_VALID_HDR_PRIMARY(inWhitePointX) || !IsSupported(kDeviceCanDoHDMIHDROut))
872  return false;
873  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrWhiteXCh1, uint32_t(inWhitePointX)))
874  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
875  return false;
876  return WriteRegister(reg, uint32_t(inWhitePointX), kRegMaskHDMIHDRWhitePointX, kRegShiftHDMIHDRWhitePointX);
877 }
878 
879 bool CNTV2Card::GetHDMIHDRWhitePointX(uint16_t & outWhitePointX, const NTV2Channel inWhichHDMIOut)
880 {
881  ULWord reg(kRegHDMIHDRWhitePoint);
882  if (!IsSupported(kDeviceCanDoHDMIHDROut))
883  return false;
884  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
885  return false;
886  return CNTV2DriverInterface::ReadRegister(reg, outWhitePointX, kRegMaskHDMIHDRWhitePointX, kRegShiftHDMIHDRWhitePointX);
887 }
888 
889 bool CNTV2Card::SetHDMIHDRWhitePointY(const uint16_t inWhitePointY, const NTV2Channel inWhichHDMIOut)
890 {
891  ULWord reg(kRegHDMIHDRWhitePoint);
892  if (!NTV2_IS_VALID_HDR_PRIMARY(inWhitePointY) || !IsSupported(kDeviceCanDoHDMIHDROut))
893  return false;
894  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrWhiteYCh1, uint32_t(inWhitePointY)))
895  return false;
896  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
897  return false;
898  return WriteRegister(reg, uint32_t(inWhitePointY), kRegMaskHDMIHDRWhitePointY, kRegShiftHDMIHDRWhitePointY);
899 }
900 
901 bool CNTV2Card::GetHDMIHDRWhitePointY(uint16_t & outWhitePointY, const NTV2Channel inWhichHDMIOut)
902 {
903  ULWord reg(kRegHDMIHDRWhitePoint);
904  if (!IsSupported(kDeviceCanDoHDMIHDROut))
905  return false;
906  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
907  return false;
908  return CNTV2DriverInterface::ReadRegister(reg, outWhitePointY, kRegMaskHDMIHDRWhitePointY, kRegShiftHDMIHDRWhitePointY);
909 }
910 
911 bool CNTV2Card::SetHDMIHDRMaxMasteringLuminance(const uint16_t inMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut)
912 {
913  ULWord reg(kRegHDMIHDRMasteringLuminence);
914  if (!NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(inMaxMasteringLuminance) || !IsSupported(kDeviceCanDoHDMIHDROut))
915  return false;
916  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMasterLumMaxCh1, uint32_t(inMaxMasteringLuminance)))
917  return false;
918  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
919  return false;
920  return WriteRegister(reg, uint32_t(inMaxMasteringLuminance), kRegMaskHDMIHDRMaxMasteringLuminance, kRegShiftHDMIHDRMaxMasteringLuminance);
921 }
922 
923 bool CNTV2Card::GetHDMIHDRMaxMasteringLuminance(uint16_t & outMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut)
924 {
925  ULWord reg(kRegHDMIHDRMasteringLuminence);
926  if (!IsSupported(kDeviceCanDoHDMIHDROut))
927  return false;
928  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
929  return false;
930  return CNTV2DriverInterface::ReadRegister(reg, outMaxMasteringLuminance, kRegMaskHDMIHDRMaxMasteringLuminance, kRegShiftHDMIHDRMaxMasteringLuminance);
931 }
932 
933 bool CNTV2Card::SetHDMIHDRMinMasteringLuminance(const uint16_t inMinMasteringLuminance, const NTV2Channel inWhichHDMIOut)
934 {
935  ULWord reg(kRegHDMIHDRMasteringLuminence);
936  if (!NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(inMinMasteringLuminance) || !IsSupported(kDeviceCanDoHDMIHDROut))
937  return false;
938  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMasterLumMinCh1, uint32_t(inMinMasteringLuminance)))
939  return false;
940  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
941  return false;
942  return WriteRegister(reg, uint32_t(inMinMasteringLuminance), kRegMaskHDMIHDRMinMasteringLuminance, kRegShiftHDMIHDRMinMasteringLuminance);
943 }
944 
945 bool CNTV2Card::GetHDMIHDRMinMasteringLuminance(uint16_t & outMinMasteringLuminance, const NTV2Channel inWhichHDMIOut)
946 {
947  ULWord reg(kRegHDMIHDRMasteringLuminence);
948  if (!IsSupported(kDeviceCanDoHDMIHDROut))
949  return false;
950  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
951  return false;
952  return CNTV2DriverInterface::ReadRegister(reg, outMinMasteringLuminance, kRegMaskHDMIHDRMinMasteringLuminance, kRegShiftHDMIHDRMinMasteringLuminance);
953 }
954 
955 bool CNTV2Card::SetHDMIHDRMaxContentLightLevel(const uint16_t inMaxContentLightLevel, const NTV2Channel inWhichHDMIOut)
956 {
957  ULWord reg(kRegHDMIHDRLightLevel);
958  if (!NTV2_IS_VALID_HDR_LIGHT_LEVEL(inMaxContentLightLevel) || !IsSupported(kDeviceCanDoHDMIHDROut))
959  return false;
960  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMaxCLLCh1, uint32_t(inMaxContentLightLevel)))
961  return false;
962  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
963  return false;
964  return WriteRegister(reg, uint32_t(inMaxContentLightLevel), kRegMaskHDMIHDRMaxContentLightLevel, kRegShiftHDMIHDRMaxContentLightLevel);
965 }
966 
967 bool CNTV2Card::GetHDMIHDRMaxContentLightLevel(uint16_t & outMaxContentLightLevel, const NTV2Channel inWhichHDMIOut)
968 {
969  ULWord reg(kRegHDMIHDRLightLevel);
970  if (!IsSupported(kDeviceCanDoHDMIHDROut))
971  return false;
972  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
973  return false;
974  return CNTV2DriverInterface::ReadRegister(reg, outMaxContentLightLevel, kRegMaskHDMIHDRMaxContentLightLevel, kRegShiftHDMIHDRMaxContentLightLevel);
975 }
976 
977 bool CNTV2Card::SetHDMIHDRMaxFrameAverageLightLevel(const uint16_t inMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut)
978 {
979  ULWord reg(kRegHDMIHDRLightLevel);
980  if(!NTV2_IS_VALID_HDR_LIGHT_LEVEL(inMaxFrameAverageLightLevel) || !IsSupported(kDeviceCanDoHDMIHDROut))
981  return false;
982  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMaxFALLCh1, uint32_t(inMaxFrameAverageLightLevel)))
983  return false;
984  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
985  return false;
986  return WriteRegister(reg, uint32_t(inMaxFrameAverageLightLevel), kRegMaskHDMIHDRMaxFrameAverageLightLevel, kRegShiftHDMIHDRMaxFrameAverageLightLevel);
987 }
988 
989 bool CNTV2Card::GetHDMIHDRMaxFrameAverageLightLevel(uint16_t & outMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut)
990 {
991  ULWord reg(kRegHDMIHDRLightLevel);
992  if (!IsSupported(kDeviceCanDoHDMIHDROut))
993  return false;
994  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
995  return false;
996  return CNTV2DriverInterface::ReadRegister(reg, outMaxFrameAverageLightLevel, kRegMaskHDMIHDRMaxFrameAverageLightLevel, kRegShiftHDMIHDRMaxFrameAverageLightLevel);
997 }
998 
999 bool CNTV2Card::SetHDMIHDRConstantLuminance(const bool inEnableConstantLuminance, const NTV2Channel inWhichHDMIOut)
1000 {
1001  ULWord reg(kRegHDMIHDRControl);
1002  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1003  return false;
1004  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrLuminanceCh1, inEnableConstantLuminance ? 1 : 0))
1005  return false;
1006  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1007  return false;
1008  return WriteRegister(reg, inEnableConstantLuminance ? 1 : 0, kRegMaskHDMIHDRNonContantLuminance, kRegShiftHDMIHDRNonContantLuminance);
1009 }
1010 
1011 bool CNTV2Card::GetHDMIHDRConstantLuminance(const NTV2Channel inWhichHDMIOut)
1012 {
1013  ULWord reg(kRegHDMIHDRControl);
1014  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1015  return false;
1016  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1017  return false;
1018  uint32_t regValue = 0;
1019  ReadRegister(reg, regValue, kRegMaskHDMIHDRNonContantLuminance, kRegShiftHDMIHDRNonContantLuminance);
1020  return regValue ? true : false;
1021 }
1022 
1023 bool CNTV2Card::SetHDMIHDRElectroOpticalTransferFunction(const uint8_t inEOTFByte, const NTV2Channel inWhichHDMIOut)
1024 {
1025  ULWord reg(kRegHDMIHDRControl);
1026  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1027  return false;
1028  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrTransferCh1, inEOTFByte))
1029  return false;
1030  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1031  return false;
1032  return WriteRegister(reg, inEOTFByte, kRegMaskElectroOpticalTransferFunction, kRegShiftElectroOpticalTransferFunction);
1033 }
1034 
1035 bool CNTV2Card::GetHDMIHDRElectroOpticalTransferFunction(uint8_t & outEOTFByte, const NTV2Channel inWhichHDMIOut)
1036 {
1037  ULWord reg(kRegHDMIHDRControl);
1038  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1039  return false;
1040  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1041  return false;
1042  return CNTV2DriverInterface::ReadRegister(reg, outEOTFByte, kRegMaskElectroOpticalTransferFunction, kRegShiftElectroOpticalTransferFunction);
1043 }
1044 
1045 bool CNTV2Card::SetHDMIHDRStaticMetadataDescriptorID(const uint8_t inSMDId, const NTV2Channel inWhichHDMIOut)
1046 {
1047  ULWord reg(kRegHDMIHDRControl);
1048  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1049  return false;
1050  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrColorimetryCh1, uint32_t(inSMDId)))
1051  return false;
1052  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1053  return false;
1054  return WriteRegister(reg, uint32_t(inSMDId), kRegMaskHDRStaticMetadataDescriptorID, kRegShiftHDRStaticMetadataDescriptorID);
1055 }
1056 
1057 bool CNTV2Card::GetHDMIHDRStaticMetadataDescriptorID(uint8_t & outSMDId, const NTV2Channel inWhichHDMIOut)
1058 {
1059  ULWord reg(kRegHDMIHDRControl);
1060  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1061  return false;
1062  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1063  return false;
1064  return CNTV2DriverInterface::ReadRegister(reg, outSMDId, kRegMaskHDRStaticMetadataDescriptorID, kRegShiftHDRStaticMetadataDescriptorID);
1065 }
1066 
1067 bool CNTV2Card::EnableHDMIHDR(const bool inEnableHDMIHDR, const NTV2Channel inWhichHDMIOut)
1068 {
1069  ULWord reg(kRegHDMIHDRControl);
1070  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1071  return false;
1072  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1073  return false;
1074 
1075  bool status = WriteRegister(reg, inEnableHDMIHDR ? 1 : 0, kRegMaskHDMIHDREnable, kRegShiftHDMIHDREnable);
1076  if (GetNumSupported(kDeviceGetHDMIVersion) < 6)
1077  WaitForOutputFieldID(NTV2_FIELD0, NTV2_CHANNEL1);
1078  return status;
1079 }
1080 
1081 bool CNTV2Card::GetHDMIHDREnabled (const NTV2Channel inWhichHDMIOut)
1082 {
1083  ULWord reg(kRegHDMIHDRControl);
1084  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1085  return false;
1086  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1087  return false;
1088 
1089  uint32_t regValue = 0;
1090  ReadRegister(reg, regValue, kRegMaskHDMIHDREnable, kRegShiftHDMIHDREnable);
1091  return regValue ? true : false;
1092 }
1093 
1094 bool CNTV2Card::EnableHDMIHDRDolbyVision(const bool inEnable, const NTV2Channel inWhichHDMIOut)
1095 {
1096  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1097  return false;
1098  ULWord reg(kRegHDMIHDRControl);
1099  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1100  return false;
1101 
1102  bool status = WriteRegister(reg, inEnable ? 1 : 0, kRegMaskHDMIHDRDolbyVisionEnable, kRegShiftHDMIHDRDolbyVisionEnable);
1103  if (GetNumSupported(kDeviceGetHDMIVersion) < 6)
1104  WaitForOutputFieldID(NTV2_FIELD0, NTV2_CHANNEL1);
1105  return status;
1106 }
1107 
1108 bool CNTV2Card::GetHDMIHDRDolbyVisionEnabled (const NTV2Channel inWhichHDMIOut)
1109 {
1110  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1111  return false;
1112  ULWord reg(kRegHDMIHDRControl);
1113  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1114  return false;
1115 
1116  bool enabled(false);
1117  return driverInterface().ReadRegister(reg, enabled, kRegMaskHDMIHDRDolbyVisionEnable, kRegShiftHDMIHDRDolbyVisionEnable) ? enabled : false;
1118 }
1119 
1120 bool CNTV2Card::SetHDRData (const HDRFloatValues & inFloatValues, const NTV2Channel inWhichHDMIOut)
1121 {
1122  HDRRegValues regValues;
1123  return inFloatValues.toRegValues(regValues) && SetHDRData(regValues, inWhichHDMIOut);
1124 }
1125 
1126 bool CNTV2Card::SetHDRData (const HDRRegValues & inRegisterValues, const NTV2Channel inWhichHDMIOut)
1127 {
1128  return SetHDMIHDRGreenPrimaryX(inRegisterValues.greenPrimaryX, inWhichHDMIOut)
1129  && SetHDMIHDRGreenPrimaryY(inRegisterValues.greenPrimaryY, inWhichHDMIOut)
1130  && SetHDMIHDRBluePrimaryX(inRegisterValues.bluePrimaryX, inWhichHDMIOut)
1131  && SetHDMIHDRBluePrimaryY(inRegisterValues.bluePrimaryY, inWhichHDMIOut)
1132  && SetHDMIHDRRedPrimaryX(inRegisterValues.redPrimaryX, inWhichHDMIOut)
1133  && SetHDMIHDRRedPrimaryY(inRegisterValues.redPrimaryY, inWhichHDMIOut)
1134  && SetHDMIHDRWhitePointX(inRegisterValues.whitePointX, inWhichHDMIOut)
1135  && SetHDMIHDRWhitePointY(inRegisterValues.whitePointY, inWhichHDMIOut)
1136  && SetHDMIHDRMaxMasteringLuminance(inRegisterValues.maxMasteringLuminance, inWhichHDMIOut)
1137  && SetHDMIHDRMinMasteringLuminance(inRegisterValues.minMasteringLuminance, inWhichHDMIOut)
1138  && SetHDMIHDRMaxContentLightLevel(inRegisterValues.maxContentLightLevel, inWhichHDMIOut)
1139  && SetHDMIHDRMaxFrameAverageLightLevel(inRegisterValues.maxFrameAverageLightLevel, inWhichHDMIOut)
1140  && SetHDMIHDRElectroOpticalTransferFunction(inRegisterValues.electroOpticalTransferFunction, inWhichHDMIOut)
1141  && SetHDMIHDRStaticMetadataDescriptorID(inRegisterValues.staticMetadataDescriptorID, inWhichHDMIOut);
1142 }
1143 
1144 bool CNTV2Card::GetHDRData (HDRFloatValues & outFloatValues, const NTV2Channel inWhichHDMIOut)
1145 {
1146  HDRRegValues regValues;
1147  return GetHDRData(regValues, inWhichHDMIOut) && outFloatValues.setFromRegValues(regValues);
1148 }
1149 
1150 bool CNTV2Card::GetHDRData (HDRRegValues & outRegisterValues, const NTV2Channel inWhichHDMIOut)
1151 {
1152  return GetHDMIHDRGreenPrimaryX(outRegisterValues.greenPrimaryX, inWhichHDMIOut)
1153  && GetHDMIHDRGreenPrimaryY(outRegisterValues.greenPrimaryY, inWhichHDMIOut)
1154  && GetHDMIHDRBluePrimaryX(outRegisterValues.bluePrimaryX, inWhichHDMIOut)
1155  && GetHDMIHDRBluePrimaryY(outRegisterValues.bluePrimaryY, inWhichHDMIOut)
1156  && GetHDMIHDRRedPrimaryX(outRegisterValues.redPrimaryX, inWhichHDMIOut)
1157  && GetHDMIHDRRedPrimaryY(outRegisterValues.redPrimaryY, inWhichHDMIOut)
1158  && GetHDMIHDRWhitePointX(outRegisterValues.whitePointX, inWhichHDMIOut)
1159  && GetHDMIHDRWhitePointY(outRegisterValues.whitePointY, inWhichHDMIOut)
1160  && GetHDMIHDRMaxMasteringLuminance(outRegisterValues.maxMasteringLuminance, inWhichHDMIOut)
1161  && GetHDMIHDRMinMasteringLuminance(outRegisterValues.minMasteringLuminance, inWhichHDMIOut)
1162  && GetHDMIHDRMaxContentLightLevel(outRegisterValues.maxContentLightLevel, inWhichHDMIOut)
1163  && GetHDMIHDRMaxFrameAverageLightLevel(outRegisterValues.maxFrameAverageLightLevel, inWhichHDMIOut)
1164  && GetHDMIHDRElectroOpticalTransferFunction(outRegisterValues.electroOpticalTransferFunction, inWhichHDMIOut)
1165  && GetHDMIHDRStaticMetadataDescriptorID(outRegisterValues.staticMetadataDescriptorID, inWhichHDMIOut);
1166 }
1167 
1168 bool CNTV2Card::SetHDMIHDRBT2020(const NTV2Channel inWhichHDMIOut)
1169 {
1170  HDRRegValues regValues;
1171  regValues.setBT2020();
1172  EnableHDMIHDR(false, inWhichHDMIOut);
1173  SetHDRData(regValues, inWhichHDMIOut);
1174  EnableHDMIHDR(true, inWhichHDMIOut);
1175  return true;
1176 }
1177 
1178 bool CNTV2Card::SetHDMIHDRDCIP3(const NTV2Channel inWhichHDMIOut)
1179 {
1180  HDRRegValues regValues;
1181  regValues.setDCIP3();
1182  EnableHDMIHDR(false, inWhichHDMIOut);
1183  SetHDRData(regValues, inWhichHDMIOut);
1184  EnableHDMIHDR(true, inWhichHDMIOut);
1185  return true;
1186 }
1187 
1188 bool CNTV2Card::GetHDMIOutAudioChannel34Swap (bool & outIsSwapped, const NTV2Channel inWhichHDMIOut)
1189 {
1190  outIsSwapped = false;
1191  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1192  return false;
1193  ULWord reg(kRegHDMIInputControl);
1194  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1195  return false;
1196  return CNTV2DriverInterface::ReadRegister(reg, outIsSwapped, kRegMaskHDMISwapOutputAudCh34, kRegShiftHDMISwapOutputAudCh34);
1197 }
1198 
1199 bool CNTV2Card::SetHDMIOutAudioChannel34Swap (const bool inIsSwapped, const NTV2Channel inWhichHDMIOut)
1200 {
1201  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1202  return false;
1203  ULWord reg(kRegHDMIInputControl);
1204  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1205  return false;
1206  return WriteRegister(reg, inIsSwapped ? 1 : 0, kRegMaskHDMISwapOutputAudCh34, kRegShiftHDMISwapOutputAudCh34);
1207 }
1208 
1209 bool CNTV2Card::EnableHDMIOutUserOverride (bool enable, const NTV2Channel inWhichHDMIOut)
1210 {
1211  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1212  return false;
1213  ULWord reg(kRegHDMIInputControl);
1214  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1215  return false;
1216  return WriteRegister(reg, enable ? 1 : 0, kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
1217 }
1218 
1219 bool CNTV2Card::GetEnableHDMIOutUserOverride (bool & isEnabled, const NTV2Channel inWhichHDMIOut)
1220 {
1221  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1222  return false;
1223  ULWord reg(kRegHDMIInputControl);
1224  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1225  return false;
1226  return driverInterface().ReadRegister(reg, isEnabled, kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
1227 }
1228 
1229 bool CNTV2Card::EnableHDMIOutCenterCrop (bool enable, const NTV2Channel inWhichHDMIOut)
1230 {
1231  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1232  return false;
1233  ULWord reg(kRegHDMIInputControl);
1234  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1235  return false;
1236  return WriteRegister(reg, enable ? 1 : 0, kRegMaskHDMIOutCropEnable, kRegShiftHDMIOutCropEnable);
1237 }
1238 
1239 bool CNTV2Card::GetEnableHDMIOutCenterCrop (bool & isEnabled, const NTV2Channel inWhichHDMIOut)
1240 {
1241  if (!GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1242  return false;
1243  ULWord reg(kRegHDMIInputControl);
1244  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1245  return false;
1246  return driverInterface().ReadRegister (reg, isEnabled, kRegMaskHDMIOutCropEnable, kRegShiftHDMIOutCropEnable);
1247 }
1248 
1249 bool CNTV2Card::GetHDMIOutControlReg (ULWord & outReg, const NTV2Channel inWhichHDMIOut)
1250 {
1251  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1252  return false;
1253  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1254  if (!hdmiVers)
1255  return false;
1256  outReg = hdmiVers < 6 ? ULWord(kRegHDMIOutControl) : gHDMIChannelToOutControlVRegNum[ULWord(inWhichHDMIOut)];
1257  return true;
1258 }
1259 
1260 bool CNTV2Card::GetHDMIOutInputStatusRegNum (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1261 {
1262  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1263  return false;
1264  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1265  if (!hdmiVers)
1266  return false;
1267  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIInputStatus) : gHDMIChannelToInputStatusVRegNum[ULWord(inWhichHDMIOut)];
1268  return true;
1269 }
1270 
1271 bool CNTV2Card::GetHDMIOutInputControlRegNum (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1272 {
1273  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1274  return false;
1275  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1276  if (!hdmiVers)
1277  return false;
1278  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIInputControl) : gHDMIChannelToInputControlVRegNum[ULWord(inWhichHDMIOut)];
1279  return true;
1280 }
1281 
1282 bool CNTV2Card::GetHDMIOutStatusReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1283 {
1284  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1285  return false;
1286  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1287  if (!hdmiVers)
1288  return false;
1289  outRegNum = hdmiVers < 6 ? ULWord(kVRegHDMIOutStatus1) : gHDMIChannelToOutStatusVRegNum[ULWord(inWhichHDMIOut)];
1290  return true;
1291 }
1292 
1293 bool CNTV2Card::GetHDMIOutHDRGreenPrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1294 {
1295  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1296  return false;
1297  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1298  if (!hdmiVers)
1299  return false;
1300  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRGreenPrimary) : gHDMIChannelToOutHDRGreenPrimaryVRegNum[ULWord(inWhichHDMIOut)];
1301  return true;
1302 }
1303 
1304 bool CNTV2Card::GetHDMIOutHDRBluePrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1305 {
1306  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1307  return false;
1308  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1309  if (!hdmiVers)
1310  return false;
1311  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRBluePrimary) : gHDMIChannelToOutHDRBluePrimaryVRegNum[ULWord(inWhichHDMIOut)];
1312  return true;
1313 }
1314 
1315 bool CNTV2Card::GetHDMIOutHDRRedPrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1316 {
1317  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1318  return false;
1319  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1320  if (!hdmiVers)
1321  return false;
1322  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRRedPrimary) : gHDMIChannelToOutHDRRedPrimaryVRegNum[ULWord(inWhichHDMIOut)];
1323  return true;
1324 }
1325 
1326 bool CNTV2Card::GetHDMIOutHDRWhitePointReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1327 {
1328  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1329  return false;
1330  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1331  if (!hdmiVers)
1332  return false;
1333  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRWhitePoint) : gHDMIChannelToOutHDRWhitePointVRegNum[ULWord(inWhichHDMIOut)];
1334  return true;
1335 }
1336 
1337 bool CNTV2Card::GetHDMIOutHDRMasterLuminanceReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1338 {
1339  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1340  return false;
1341  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1342  if (!hdmiVers)
1343  return false;
1344  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRMasteringLuminence) : gHDMIChannelToOutHDRMasterLuminanceVRegNum[ULWord(inWhichHDMIOut)];
1345  return true;
1346 }
1347 
1348 bool CNTV2Card::GetHDMIOutHDRLightLevelReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1349 {
1350  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1351  return false;
1352  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1353  if (!hdmiVers)
1354  return false;
1355  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRLightLevel) : gHDMIChannelToOutHDRLightLevelVRegNum[ULWord(inWhichHDMIOut)];
1356  return true;
1357 }
1358 
1359 bool CNTV2Card::GetHDMIOutHDRControlReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1360 {
1361  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1362  return false;
1363  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1364  if (!hdmiVers)
1365  return false;
1366  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRControl) : gHDMIChannelToOutHDRControlVRegNum[ULWord(inWhichHDMIOut)];
1367  return true;
1368 }
1369 
1371 
1372 #ifdef MSWindows
1373 #pragma warning(default: 4800)
1374 #endif
CNTV2Card::SetHDMIOutAudioChannel34Swap
virtual bool SetHDMIOutAudioChannel34Swap(const bool inIsSwapped, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the HDMI output&#39;s audio channel 3/4 swap state.
Definition: ntv2hdmi.cpp:1199
CNTV2Card::EnableHDMIOutCenterCrop
virtual bool EnableHDMIOutCenterCrop(const bool inEnable, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Controls the 4k/2k -> UHD/HD HDMI center cropping feature.
Definition: ntv2hdmi.cpp:1229
CNTV2Card::SetHDRData
virtual bool SetHDRData(const HDRFloatValues &inFloatValues, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1120
CNTV2Card::SetHDMIOutProtocol
virtual bool SetHDMIOutProtocol(const NTV2HDMIProtocol inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the protocol to use for the given HDMI output.
Definition: ntv2hdmi.cpp:569
CNTV2Card::SetHDMIOut3DMode
virtual bool SetHDMIOut3DMode(const NTV2HDMIOut3DMode inValue)
Definition: ntv2hdmi.cpp:326
CNTV2Card::SetHDMIOutBitDepth
virtual bool SetHDMIOutBitDepth(const NTV2HDMIBitDepth inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the bit depth to use for the given HDMI output.
Definition: ntv2hdmi.cpp:511
CNTV2Card::SetHDMIHDRMinMasteringLuminance
virtual bool SetHDMIHDRMinMasteringLuminance(const uint16_t inMinMasteringLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for the Min Mastering Luminance value as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:933
CNTV2Card::SetHDMIV2Mode
virtual bool SetHDMIV2Mode(const NTV2HDMIV2Mode inMode)
Sets HDMI V2 mode for the device.
Definition: ntv2hdmi.cpp:709
NTV2_HDMIColorSpaceYCbCr
YCbCr color space.
Definition: ntv2enums.h:3612
CNTV2Card::GetLHIHDMIOutColorSpace
virtual bool GetLHIHDMIOutColorSpace(NTV2LHIHDMIColorSpace &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the color space of the given HDMI output (YCbCr or RGB).
Definition: ntv2hdmi.cpp:483
CNTV2Card::SetHDMIHDRMaxMasteringLuminance
virtual bool SetHDMIHDRMaxMasteringLuminance(const uint16_t inMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for the Max Mastering Luminance value as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:911
gHDMIChannelToInputControlVRegNum
static const ULWord gHDMIChannelToInputControlVRegNum[]
Definition: ntv2hdmi.cpp:28
NTV2HDMIColorSpace
NTV2HDMIColorSpace
Indicates or specifies HDMI Color Space.
Definition: ntv2enums.h:3608
CNTV2Card::SetLHIHDMIOutColorSpace
virtual bool SetLHIHDMIOutColorSpace(const NTV2LHIHDMIColorSpace inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the color space to use for the given HDMI output.
Definition: ntv2hdmi.cpp:475
CNTV2Card::SetHDMIOutDecimateMode
virtual bool SetHDMIOutDecimateMode(const bool inEnable)
Enables or disables decimate mode on the device&#39;s HDMI rasterizer, which halves the output frame rate...
Definition: ntv2hdmi.cpp:667
CNTV2Card::GetHDMIOutDownstreamBitDepth
virtual bool GetHDMIOutDownstreamBitDepth(NTV2HDMIBitDepth &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the bit depth of the downstream device connected to the given HDMI output.
Definition: ntv2hdmi.cpp:495
CNTV2Card::GetHDMIInDolbyVision
virtual bool GetHDMIInDolbyVision(bool &outIsDetected, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s Dolby Vision flag value.
Definition: ntv2hdmi.cpp:166
CNTV2Card::GetHDMIHDRGreenPrimaryY
virtual bool GetHDMIHDRGreenPrimaryY(uint16_t &outGreenPrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Green Primary Y as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:771
BIT
#define BIT(_x_)
Definition: ajatypes.h:596
HDRRegValues
defined(NTV2_DEPRECATE_17_6)
Definition: ntv2publicinterface.h:10255
CNTV2Card::GetHDMIOutHDRBluePrimaryReg
virtual bool GetHDMIOutHDRBluePrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1304
gHDMIChannelToOutHDRBluePrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRBluePrimaryVRegNum[]
Definition: ntv2hdmi.cpp:36
CNTV2Card::SetHDMIInBitDepth
virtual bool SetHDMIInBitDepth(const NTV2HDMIBitDepth inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input&#39;s bit depth.
Definition: ntv2hdmi.cpp:212
CNTV2Card::SetHDMIOutPrefer420
virtual bool SetHDMIOutPrefer420(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets if the given HDMI output should prefer 4:2:0 or not.
Definition: ntv2hdmi.cpp:619
CNTV2Card::GetHDMIOutDecimateMode
virtual bool GetHDMIOutDecimateMode(bool &outIsEnabled)
Definition: ntv2hdmi.cpp:674
HDRRegValues::minMasteringLuminance
uint16_t minMasteringLuminance
Definition: ntv2publicinterface.h:10266
CNTV2Card::GetHDMIHDRMinMasteringLuminance
virtual bool GetHDMIHDRMinMasteringLuminance(uint16_t &outMinMasteringLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for the Min Mastering Luminance value as defined in SMPTE ST ...
Definition: ntv2hdmi.cpp:945
CNTV2Card::GetHDMIInAudioSampleRateConverterEnable
virtual bool GetHDMIInAudioSampleRateConverterEnable(bool &outIsEnabled, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:269
CNTV2Card::SetHDMIOut3DPresent
virtual bool SetHDMIOut3DPresent(const bool inIs3DPresent)
Definition: ntv2hdmi.cpp:314
GetIndexForNTV2Channel
ULWord GetIndexForNTV2Channel(const NTV2Channel inChannel)
Definition: ntv2utils.cpp:4704
CNTV2Card::GetHDMIOutForceYUV
virtual bool GetHDMIOutForceYUV(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers if the given HDMI output is forced to YUV color.
Definition: ntv2hdmi.cpp:643
CNTV2Card::GetHDMIOutHDRLightLevelReg
virtual bool GetHDMIOutHDRLightLevelReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1348
CNTV2Card::SetHDMIInAudioChannel34Swap
virtual bool SetHDMIInAudioChannel34Swap(const bool inIsSwapped, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input&#39;s audio channel 3/4 swap state.
Definition: ntv2hdmi.cpp:304
isEnabled
static bool isEnabled(CNTV2Card &device, const NTV2Channel inChannel)
Definition: ntv2supportlogger.cpp:143
CNTV2Card::SetHDMIInputRange
virtual bool SetHDMIInputRange(const NTV2HDMIRange inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input&#39;s input range.
Definition: ntv2hdmi.cpp:176
gHDMIChannelToOutHDRWhitePointVRegNum
static const ULWord gHDMIChannelToOutHDRWhitePointVRegNum[]
Definition: ntv2hdmi.cpp:38
CNTV2Card::GetHDMIHDREnabled
virtual bool GetHDMIHDREnabled(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1081
CNTV2Card::GetHDMIInputRange
virtual bool GetHDMIInputRange(NTV2HDMIRange &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s current input range setting.
Definition: ntv2hdmi.cpp:185
std
Definition: json.hpp:5362
NTV2HDMIAudioChannels
NTV2HDMIAudioChannels
Indicates or specifies the HDMI audio channel count.
Definition: ntv2enums.h:3670
HDRRegValues::maxFrameAverageLightLevel
uint16_t maxFrameAverageLightLevel
Definition: ntv2publicinterface.h:10268
gHDMIChannelToOutHDRRedPrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRRedPrimaryVRegNum[]
Definition: ntv2hdmi.cpp:34
NTV2HDMIRange
NTV2HDMIRange
Indicates or specifies the HDMI RGB range.
Definition: ntv2enums.h:3638
ULWord
uint32_t ULWord
Definition: ajatypes.h:236
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They&#39;re also commonly use...
Definition: ntv2enums.h:1359
CNTV2Card::SetHDMIV2TxBypass
virtual bool SetHDMIV2TxBypass(const bool inBypass)
Definition: ntv2hdmi.cpp:362
CNTV2Card::GetHDMIInIsLocked
virtual bool GetHDMIInIsLocked(bool &outIsLocked, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers if the given HDMI input is genlocked or not.
Definition: ntv2hdmi.cpp:248
CNTV2Card::GetHDMIInputColor
virtual bool GetHDMIInputColor(NTV2LHIHDMIColorSpace &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the current colorspace for the given HDMI input.
Definition: ntv2hdmi.cpp:70
gHDMIChannelToInputStatusVRegNum
static const ULWord gHDMIChannelToInputStatusVRegNum[]
Definition: ntv2hdmi.cpp:26
CNTV2Card::GetHDMIHDRElectroOpticalTransferFunction
virtual bool GetHDMIHDRElectroOpticalTransferFunction(uint8_t &outEOTFByte, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1035
CNTV2Card::GetHDMIOut3DPresent
virtual bool GetHDMIOut3DPresent(bool &outIs3DPresent)
Definition: ntv2hdmi.cpp:320
CNTV2Card::GetEnableHDMIOutCenterCrop
virtual bool GetEnableHDMIOutCenterCrop(bool &outIsEnabled, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers if the HDMI 4k/2k -> UHD/HD center cropping is enabled or not.
Definition: ntv2hdmi.cpp:1239
CNTV2Card::GetHDMIOutDownstreamColorSpace
virtual bool GetHDMIOutDownstreamColorSpace(NTV2LHIHDMIColorSpace &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the color space of the downstream device connected to the given HDMI output...
Definition: ntv2hdmi.cpp:503
CNTV2Card::SetHDMIOutLevelBMode
virtual bool SetHDMIOutLevelBMode(const bool inEnable)
Enables or disables level-B mode on the device&#39;s HDMI rasterizer.
Definition: ntv2hdmi.cpp:695
CNTV2Card::SetHDMIHDRConstantLuminance
virtual bool SetHDMIHDRConstantLuminance(const bool inEnableConstantLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables BT.2020 Y&#39;cC&#39;bcC&#39;rc versus BT.2020 Y&#39;C&#39;bC&#39;r or R&#39;G&#39;B&#39;.
Definition: ntv2hdmi.cpp:999
CNTV2Card::SetHDMIInAudioSampleRateConverterEnable
virtual bool SetHDMIInAudioSampleRateConverterEnable(const bool inNewValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:261
CNTV2Card::GetHDMIOut3DMode
virtual bool GetHDMIOut3DMode(NTV2HDMIOut3DMode &outValue)
Definition: ntv2hdmi.cpp:332
CNTV2Card::GetHDMIOutLevelBMode
virtual bool GetHDMIOutLevelBMode(bool &outIsEnabled)
Definition: ntv2hdmi.cpp:702
CNTV2Card::GetHDMIHDRWhitePointX
virtual bool GetHDMIHDRWhitePointX(uint16_t &outWhitePointX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for White Point X as defined in SMPTE ST 2086. This is Byte 15 and 16 of SMDT Type 1.
Definition: ntv2hdmi.cpp:879
CNTV2Card::GetHDMIOutPrefer420
virtual bool GetHDMIOutPrefer420(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers if the given HDMI output prefers 4:2:0 video (rather than, say, 4:2:2 or higher).
Definition: ntv2hdmi.cpp:627
gHDMIChannelToOutHDRLightLevelVRegNum
static const ULWord gHDMIChannelToOutHDRLightLevelVRegNum[]
Definition: ntv2hdmi.cpp:42
CNTV2Card::SetHDMIHDRDCIP3
virtual bool SetHDMIHDRDCIP3(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1178
NTV2HDMIOutputStatus::Clear
void Clear(void)
Resets me to an invalid state.
Definition: ntv2publicinterface.cpp:171
CNTV2Card::GetHDMIOutHDRWhitePointReg
virtual bool GetHDMIOutHDRWhitePointReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1326
CNTV2Card::SetHDMIOutForceRGB
virtual bool SetHDMIOutForceRGB(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets if the given HDMI output to RGB color.
Definition: ntv2hdmi.cpp:651
NTV2FrameRate
NTV2FrameRate
Identifies a particular video frame rate.
Definition: ntv2enums.h:414
true
#define true
Definition: ntv2devicefeatures.h:26
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:167
HDRRegValues::electroOpticalTransferFunction
uint8_t electroOpticalTransferFunction
Definition: ntv2publicinterface.h:10269
CNTV2Card::SetHDMIOutDisable
virtual bool SetHDMIOutDisable(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:603
CNTV2Card::GetHDRData
virtual bool GetHDRData(HDRFloatValues &outFloatValues, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1144
gHDMIChannelToControlRegNum
static const ULWord gHDMIChannelToControlRegNum[]
Definition: ntv2hdmi.cpp:21
CNTV2Card::SetHDMIOutRange
virtual bool SetHDMIOutRange(const NTV2HDMIRange inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the video pixel value range limiting, if any, to use for the given HDMI output.
Definition: ntv2hdmi.cpp:408
NTV2_IS_VALID_HDR_MASTERING_LUMINENCE
#define NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(__val__)
Definition: ntv2publicinterface.h:10384
NTV2_HDMIColorSpaceRGB
RGB color space.
Definition: ntv2enums.h:3611
CNTV2Card::GetHDMIInColorSpace
virtual bool GetHDMIInColorSpace(NTV2HDMIColorSpace &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s current color space setting.
Definition: ntv2hdmi.cpp:203
CNTV2Card::SetHDMIOutSampleStructure
virtual bool SetHDMIOutSampleStructure(const NTV2HDMISampleStructure inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the video pixel sample structure to use for the given HDMI output.
Definition: ntv2hdmi.cpp:368
NTV2_IS_VALID_HDMI_RANGE
#define NTV2_IS_VALID_HDMI_RANGE(__x__)
Definition: ntv2enums.h:3646
CNTV2Card::GetHDMIOutStatusReg
virtual bool GetHDMIOutStatusReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1282
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:454
CNTV2Card::GetHDMIOutAudioChannel34Swap
virtual bool GetHDMIOutAudioChannel34Swap(bool &outIsSwapped, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the HDMI output&#39;s current audio channel 3/4 swap setting.
Definition: ntv2hdmi.cpp:1188
NTV2HDMIOutputStatus
Reports HDMI output status information.
Definition: ntv2publicinterface.h:7189
CNTV2Card::GetHDMIInColorimetry
virtual bool GetHDMIInColorimetry(NTV2HDMIColorimetry &outColorimetry, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s current colorimetry.
Definition: ntv2hdmi.cpp:157
CNTV2Card::SetHDMIHDRGreenPrimaryY
virtual bool SetHDMIHDRGreenPrimaryY(const uint16_t inGreenPrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Green Primary Y as defined in SMPTE ST 2086. This is Byte 5 and 6...
Definition: ntv2hdmi.cpp:759
CNTV2Card::GetHDMIInAudioChannel34Swap
virtual bool GetHDMIInAudioChannel34Swap(bool &outIsSwapped, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s current audio channel 3/4 swap setting.
Definition: ntv2hdmi.cpp:294
CNTV2Card::SetHDMIHDRMaxContentLightLevel
virtual bool SetHDMIHDRMaxContentLightLevel(const uint16_t inMaxContentLightLevel, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for the Max Content Light Level(Max CLL) value. This is Byte 23 and 2...
Definition: ntv2hdmi.cpp:955
CNTV2Card::GetHDMIV2Mode
virtual bool GetHDMIV2Mode(NTV2HDMIV2Mode &outMode)
Answers with the current HDMI V2 mode of the device.
Definition: ntv2hdmi.cpp:716
CNTV2Card::SetHDMIOutVideoStandard
virtual bool SetHDMIOutVideoStandard(const NTV2Standard inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the video standard to use for the given HDMI output.
Definition: ntv2hdmi.cpp:339
CNTV2Card::EnableHDMIOutUserOverride
virtual bool EnableHDMIOutUserOverride(const bool inEnable, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables override of HDMI parameters.
Definition: ntv2hdmi.cpp:1209
gKonaHDMICtrlRegs
static const ULWord gKonaHDMICtrlRegs[]
Definition: ntv2hdmi.cpp:292
CNTV2Card::GetHDMIInVideoRange
virtual bool GetHDMIInVideoRange(NTV2HDMIRange &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s video black/white range.
Definition: ntv2hdmi.cpp:79
HDRRegValues::maxMasteringLuminance
uint16_t maxMasteringLuminance
Definition: ntv2publicinterface.h:10265
NTV2HDMIProtocol
NTV2HDMIProtocol
Indicates or specifies the HDMI protocol.
Definition: ntv2enums.h:3624
NTV2_IS_VALID_HDR_PRIMARY
#define NTV2_IS_VALID_HDR_PRIMARY(__val__)
Definition: ntv2publicinterface.h:10383
CNTV2Card::GetHDMIOutControlReg
virtual bool GetHDMIOutControlReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1249
NTV2_IS_VALID_HDMI_PROTOCOL
#define NTV2_IS_VALID_HDMI_PROTOCOL(__x__)
Definition: ntv2enums.h:3632
DEVICE_ID_KONAHDMI
See KONA HDMI.
Definition: ntv2enums.h:68
CNTV2Card::GetHDMIHDRBluePrimaryX
virtual bool GetHDMIHDRBluePrimaryX(uint16_t &outBluePrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Blue Primary X as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:793
CNTV2Card::SetHDMIHDRGreenPrimaryX
virtual bool SetHDMIHDRGreenPrimaryX(const uint16_t inGreenPrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Green Primary X as defined in SMPTE ST 2086. This is Byte 3 and 4...
Definition: ntv2hdmi.cpp:737
NTV2HDMIV2Mode
NTV2HDMIV2Mode
Definition: ntv2enums.h:4003
CNTV2Card::GetHDMIOutHDRRedPrimaryReg
virtual bool GetHDMIOutHDRRedPrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1315
CNTV2Card::GetHDMIOutForceRGB
virtual bool GetHDMIOutForceRGB(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers if the given HDMI output is forced to RGB color.
Definition: ntv2hdmi.cpp:659
NTV2_CHANNEL2
Specifies channel or FrameStore 2 (or the 2nd item).
Definition: ntv2enums.h:1362
HDRRegValues::setDCIP3
HDRRegValues & setDCIP3(void)
Definition: ntv2publicinterface.h:10286
CNTV2Card::GetHDMIHDRBluePrimaryY
virtual bool GetHDMIHDRBluePrimaryY(uint16_t &outBluePrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Blue Primary Y as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:815
CNTV2Card::GetEnableHDMIOutUserOverride
virtual bool GetEnableHDMIOutUserOverride(bool &outIsEnabled, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers if override of HDMI parameters is enabled or not.
Definition: ntv2hdmi.cpp:1219
HDRRegValues::maxContentLightLevel
uint16_t maxContentLightLevel
Definition: ntv2publicinterface.h:10267
DEVICE_ID_KONALHIDVI
See KONA LHi.
Definition: ntv2enums.h:79
NTV2_IS_VALID_HDMI_SAMPLE_STRUCT
#define NTV2_IS_VALID_HDMI_SAMPLE_STRUCT(_x_)
Definition: ntv2enums.h:4201
CNTV2Card::GetHDMIHDRConstantLuminance
virtual bool GetHDMIHDRConstantLuminance(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1011
CNTV2Card::SetHDMIHDRRedPrimaryY
virtual bool SetHDMIHDRRedPrimaryY(const uint16_t inRedPrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Red Primary Y as defined in SMPTE ST 2086. This is Byte 13 and 14...
Definition: ntv2hdmi.cpp:846
CNTV2Card::EnableHDMIHDRDolbyVision
virtual bool EnableHDMIHDRDolbyVision(const bool inEnable, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables HDMI HDR Dolby Vision.
Definition: ntv2hdmi.cpp:1094
kDeviceGetNumHDMIVideoOutputs
The number of HDMI video outputs on the device.
Definition: ntv2devicefeatures.h:208
gHDMIChannelToOutStatusVRegNum
static const ULWord gHDMIChannelToOutStatusVRegNum[]
Definition: ntv2hdmi.cpp:30
CNTV2Card::GetHDMIOutInputControlRegNum
virtual bool GetHDMIOutInputControlRegNum(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1271
NTV2HDMIColorimetry
NTV2HDMIColorimetry
Indicates or specifies the HDMI colorimetry.
Definition: ntv2enums.h:3652
CNTV2Card::GetHDMIOutColorSpace
virtual bool GetHDMIOutColorSpace(NTV2HDMIColorSpace &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:450
gHDMIChannelToInputStatusRegNum
static const ULWord gHDMIChannelToInputStatusRegNum[]
Definition: ntv2hdmi.cpp:20
CNTV2Card::SetHDMIHDRBluePrimaryY
virtual bool SetHDMIHDRBluePrimaryY(const uint16_t inBluePrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Blue Primary Y as defined in SMPTE ST 2086. This is Byte 9 and 10...
Definition: ntv2hdmi.cpp:803
CNTV2Card::GetHDMIOutHDRControlReg
virtual bool GetHDMIOutHDRControlReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1359
CNTV2Card::GetHDMIInputAudioChannels
virtual bool GetHDMIInputAudioChannels(NTV2HDMIAudioChannels &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the current number of audio channels being received on the given HDMI input...
Definition: ntv2hdmi.cpp:280
NTV2_HDMIAudio2Channels
2 audio channels
Definition: ntv2enums.h:3672
CNTV2Card::GetHDMIInputStatus
virtual bool GetHDMIInputStatus(ULWord &outValue, const NTV2Channel inChannel=NTV2_CHANNEL1, const bool in12BitDetection=(0))
Answers with the contents of the HDMI Input status register for the given HDMI input.
Definition: ntv2hdmi.cpp:64
CNTV2Card::GetHDMIHDRMaxFrameAverageLightLevel
virtual bool GetHDMIHDRMaxFrameAverageLightLevel(uint16_t &outMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for the Max Frame Average Light Level(Max FALL) value...
Definition: ntv2hdmi.cpp:989
NTV2_IS_VALID_HDR_LIGHT_LEVEL
#define NTV2_IS_VALID_HDR_LIGHT_LEVEL(__val__)
Definition: ntv2publicinterface.h:10385
CNTV2Card::GetHDMIOutProtocol
virtual bool GetHDMIOutProtocol(NTV2HDMIProtocol &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the protocol being used for the given HDMI output (DVI or HDMI).
Definition: ntv2hdmi.cpp:579
CNTV2Card::SetHDMIHDRStaticMetadataDescriptorID
virtual bool SetHDMIHDRStaticMetadataDescriptorID(const uint8_t inSMDId, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1045
CNTV2Card::GetHDMIHDRGreenPrimaryX
virtual bool GetHDMIHDRGreenPrimaryX(uint16_t &outGreenPrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Green Primary X as defined in SMPTE ST 2086...
Definition: ntv2hdmi.cpp:749
CNTV2Card::EnableHDMIHDR
virtual bool EnableHDMIHDR(const bool inEnableHDMIHDR, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables HDMI HDR.
Definition: ntv2hdmi.cpp:1067
CNTV2Card::GetHDMIOutStatus
virtual bool GetHDMIOutStatus(NTV2HDMIOutputStatus &outStatus, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the current HDMI output status.
Definition: ntv2hdmi.cpp:723
CNTV2Card::SetHDMIHDRBT2020
virtual bool SetHDMIHDRBT2020(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1168
CNTV2Card::SetHDMIHDRMaxFrameAverageLightLevel
virtual bool SetHDMIHDRMaxFrameAverageLightLevel(const uint16_t inMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for the Max Frame Average Light Level(Max FALL) value. This is Byte 25 and 26 of SMDT Type 1.
Definition: ntv2hdmi.cpp:977
CNTV2Card::SetHDMIOutForceConfig
virtual bool SetHDMIOutForceConfig(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:587
CNTV2Card::SetHDMIOutColorSpace
virtual bool SetHDMIOutColorSpace(const NTV2HDMIColorSpace inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:428
CNTV2Card::SetHDMIHDRRedPrimaryX
virtual bool SetHDMIHDRRedPrimaryX(const uint16_t inRedPrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Red Primary X as defined in SMPTE ST 2086. This is Byte 11 and 12...
Definition: ntv2hdmi.cpp:825
CNTV2Card::GetHDMIHDRRedPrimaryX
virtual bool GetHDMIHDRRedPrimaryX(uint16_t &outRedPrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Red Primary X as defined in SMPTE ST 2086. This is Byte 11 and 12 of SMDT Type 1.
Definition: ntv2hdmi.cpp:836
UWord
uint16_t UWord
Definition: ajatypes.h:234
kDeviceCanDoHDMIHDROut
True if device supports HDMI HDR output.
Definition: ntv2devicefeatures.h:115
CNTV2Card::SetHDMIOutVideoFPS
virtual bool SetHDMIOutVideoFPS(const NTV2FrameRate inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the video frame rate to use for the given HDMI output.
Definition: ntv2hdmi.cpp:388
NTV2_CHANNEL1
Specifies channel or FrameStore 1 (or the first item).
Definition: ntv2enums.h:1361
CNTV2Card::GetHDMIHDRWhitePointY
virtual bool GetHDMIHDRWhitePointY(uint16_t &outWhitePointY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for White Point Y as defined in SMPTE ST 2086. This is Byte 17 and 18 of SMDT Type 1.
Definition: ntv2hdmi.cpp:901
CNTV2Card::GetHDMIInputStatusRegNum
virtual bool GetHDMIInputStatusRegNum(ULWord &outRegNum, const NTV2Channel inChannel=NTV2_CHANNEL1, const bool in12BitDetection=(0))
Answers with the HDMI Input status register number for the given HDMI input.
Definition: ntv2hdmi.cpp:51
CNTV2Card::SetHDMIHDRElectroOpticalTransferFunction
virtual bool SetHDMIHDRElectroOpticalTransferFunction(const uint8_t inEOTFByte, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1023
HDRFloatValues::toRegValues
bool toRegValues(HDRRegValues &outVals) const
Definition: ntv2publicinterface.h:10345
HDRFloatValues::zero
HDRFloatValues & zero(void)
Definition: ntv2publicinterface.h:10312
HDRFloatValues::setFromRegValues
bool setFromRegValues(const HDRRegValues &inRegValues)
Definition: ntv2publicinterface.h:10326
CNTV2Card::SetHDMIOutTsiIO
virtual bool SetHDMIOutTsiIO(const bool inTsiEnable)
Enables or disables two sample interleave I/O mode on the device&#39;s HDMI rasterizer.
Definition: ntv2hdmi.cpp:681
NTV2HDMIOutputStatus::SetFromRegValue
bool SetFromRegValue(const ULWord inData)
Sets my fields from the given status register value.
Definition: ntv2publicinterface.cpp:186
ntv2card.h
Declares the CNTV2Card class.
CNTV2Card::GetHDMIHDRMaxMasteringLuminance
virtual bool GetHDMIHDRMaxMasteringLuminance(uint16_t &outMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for the Max Mastering Luminance value as defined in SMPTE ST ...
Definition: ntv2hdmi.cpp:923
CNTV2Card::GetHDMIInBitDepth
virtual bool GetHDMIInBitDepth(NTV2HDMIBitDepth &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s current bit depth setting.
Definition: ntv2hdmi.cpp:225
kDeviceGetHDMIVersion
The version number of the HDMI chipset on the device.
Definition: ntv2devicefeatures.h:181
CNTV2Card::GetHDMIOutHDRGreenPrimaryReg
virtual bool GetHDMIOutHDRGreenPrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1293
CNTV2Card::GetHDMIOutTsiIO
virtual bool GetHDMIOutTsiIO(bool &tsiEnabled)
Definition: ntv2hdmi.cpp:688
CNTV2Card::GetHDMIOutVideoFPS
virtual bool GetHDMIOutVideoFPS(NTV2FrameRate &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the video frame rate being used for the given HDMI output.
Definition: ntv2hdmi.cpp:399
HDRRegValues::staticMetadataDescriptorID
uint8_t staticMetadataDescriptorID
Definition: ntv2publicinterface.h:10270
NTV2_FIELD0
Identifies the first field in time for an interlaced video frame, or the first and only field in a pr...
Definition: ntv2enums.h:1845
CNTV2Card::SetHDMIHDRBluePrimaryX
virtual bool SetHDMIHDRBluePrimaryX(const uint16_t inBluePrimaryX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for Blue Primary X as defined in SMPTE ST 2086. This is Byte 7 and 8 ...
Definition: ntv2hdmi.cpp:781
NTV2_HDMIAudio8Channels
8 audio channels
Definition: ntv2enums.h:3673
CNTV2Card::SetHDMIInColorSpace
virtual bool SetHDMIInColorSpace(const NTV2HDMIColorSpace inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input&#39;s color space.
Definition: ntv2hdmi.cpp:194
CNTV2Card::GetHDMIOutInputStatusRegNum
virtual bool GetHDMIOutInputStatusRegNum(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1260
gHDMIChannelToOutHDRMasterLuminanceVRegNum
static const ULWord gHDMIChannelToOutHDRMasterLuminanceVRegNum[]
Definition: ntv2hdmi.cpp:40
CNTV2Card::GetHDMIOutBitDepth
virtual bool GetHDMIOutBitDepth(NTV2HDMIBitDepth &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the bit depth of the given HDMI output (8, 10 or 12 bits).
Definition: ntv2hdmi.cpp:544
CNTV2Card::GetHDMIHDRMaxContentLightLevel
virtual bool GetHDMIHDRMaxContentLightLevel(uint16_t &outMaxContentLightLevel, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for the Max Content Light Level(Max CLL) value. This is Byte 23 and 24 of SMDT Type 1.
Definition: ntv2hdmi.cpp:967
CNTV2Card::GetHDMIHDRStaticMetadataDescriptorID
virtual bool GetHDMIHDRStaticMetadataDescriptorID(uint8_t &outSMDId, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1057
HDRRegValues::zero
HDRRegValues & zero(void)
Definition: ntv2publicinterface.h:10273
CNTV2Card::GetHDMIOutRange
virtual bool GetHDMIOutRange(NTV2HDMIRange &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the video pixel value range limiting, if any, for the given HDMI output (SMPTE or none)...
Definition: ntv2hdmi.cpp:418
NTV2HDMISampleStructure
NTV2HDMISampleStructure
Definition: ntv2enums.h:4190
CNTV2Card::SetHDMIOutForceYUV
virtual bool SetHDMIOutForceYUV(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets if the given HDMI output to YUV color.
Definition: ntv2hdmi.cpp:635
NTV2HDMIBitDepth
NTV2HDMIBitDepth
Indicates or specifies the HDMI video bit depth.
Definition: ntv2enums.h:3695
CNTV2Card::GetHDMIOutHDRMasterLuminanceReg
virtual bool GetHDMIOutHDRMasterLuminanceReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1337
ntv2devicefeatures.h
Declares device capability functions.
HDRRegValues::setBT2020
HDRRegValues & setBT2020(void)
Definition: ntv2publicinterface.h:10281
NTV2_IS_VALID_NTV2FrameRate
#define NTV2_IS_VALID_NTV2FrameRate(__r__)
Definition: ntv2enums.h:446
NTV2HDMIOut3DMode
NTV2HDMIOut3DMode
This specifies the HDMI Out Stereo 3D Mode.
Definition: ntv2enums.h:3596
CNTV2Card::GetHDMIOutForceConfig
virtual bool GetHDMIOutForceConfig(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:595
gHDMIChannelToOutHDRGreenPrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRGreenPrimaryVRegNum[]
Definition: ntv2hdmi.cpp:32
CNTV2Card::GetHDMIOutDisable
virtual bool GetHDMIOutDisable(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:611
NTV2LHIHDMIColorSpace
NTV2LHIHDMIColorSpace
Definition: ntv2enums.h:3681
CNTV2Card::SetHDMIHDRWhitePointX
virtual bool SetHDMIHDRWhitePointX(const uint16_t inWhitePointX, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for White Point X as defined in SMPTE ST 2086. This is Byte 15 and 16...
Definition: ntv2hdmi.cpp:868
NTV2_IS_VALID_HDMI_BITDEPTH
#define NTV2_IS_VALID_HDMI_BITDEPTH(__x__)
Definition: ntv2enums.h:3704
gHDMIChannelToOutHDRControlVRegNum
static const ULWord gHDMIChannelToOutHDRControlVRegNum[]
Definition: ntv2hdmi.cpp:44
CNTV2Card::GetHDMIOutSampleStructure
virtual bool GetHDMIOutSampleStructure(NTV2HDMISampleStructure &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the video pixel sample structure being used for the given HDMI output.
Definition: ntv2hdmi.cpp:379
CNTV2Card::GetHDMIInDynamicRange
virtual bool GetHDMIInDynamicRange(HDRRegValues &outRegValues, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s video dynamic range and mastering information.
Definition: ntv2hdmi.cpp:88
CNTV2Card::GetHDMIOutVideoStandard
virtual bool GetHDMIOutVideoStandard(NTV2Standard &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the video standard being used for the given HDMI output.
Definition: ntv2hdmi.cpp:349
kDeviceGetNumHDMIVideoInputs
The number of HDMI video inputs on the device.
Definition: ntv2devicefeatures.h:207
gHDMIChannelToOutControlVRegNum
static const ULWord gHDMIChannelToOutControlVRegNum[]
Definition: ntv2hdmi.cpp:24
CNTV2Card::SetHDMIHDRWhitePointY
virtual bool SetHDMIHDRWhitePointY(const uint16_t inWhitePointY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the Display Mastering data for White Point Y as defined in SMPTE ST 2086. This is Byte 17 and 18...
Definition: ntv2hdmi.cpp:889
CNTV2Card::GetHDMIHDRRedPrimaryY
virtual bool GetHDMIHDRRedPrimaryY(uint16_t &outRedPrimaryY, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the Display Mastering data for Red Primary Y as defined in SMPTE ST 2086. This is Byte 13 and 14 of SMDT Type 1.
Definition: ntv2hdmi.cpp:858
CNTV2Card::GetHDMIInProtocol
virtual bool GetHDMIInProtocol(NTV2HDMIProtocol &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input&#39;s protocol.
Definition: ntv2hdmi.cpp:238
CNTV2Card::GetHDMIHDRDolbyVisionEnabled
virtual bool GetHDMIHDRDolbyVisionEnabled(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1108