AJA NTV2 SDK  17.6.0.2675
NTV2 SDK 17.6.0.2675
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 (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 (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 
636 bool CNTV2Card::SetHDMIOutDecimateMode (const bool inIsEnabled)
637 {
638  return GetNumSupported(kDeviceGetHDMIVersion) > 1
639  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
640  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskRasterDecimate, kRegShiftRasterDecimate);
641 }
642 
643 bool CNTV2Card::GetHDMIOutDecimateMode(bool & outIsEnabled)
644 {
645  return GetNumSupported(kDeviceGetHDMIVersion) > 1
646  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
647  && CNTV2DriverInterface::ReadRegister (kRegRasterizerControl, outIsEnabled, kRegMaskRasterDecimate, kRegShiftRasterDecimate);
648 }
649 
650 bool CNTV2Card::SetHDMIOutTsiIO (const bool inIsEnabled)
651 {
652  return GetNumSupported(kDeviceGetHDMIVersion) > 1
653  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
654  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskTsiIO, kRegShiftTsiIO);
655 }
656 
657 bool CNTV2Card::GetHDMIOutTsiIO (bool & outIsEnabled)
658 {
659  return GetNumSupported(kDeviceGetHDMIVersion) > 1
660  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
661  && CNTV2DriverInterface::ReadRegister(kRegRasterizerControl, outIsEnabled, kRegMaskTsiIO, kRegShiftTsiIO);
662 }
663 
664 bool CNTV2Card::SetHDMIOutLevelBMode (const bool inIsEnabled)
665 {
666  return GetNumSupported(kDeviceGetHDMIVersion) > 1
667  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
668  && WriteRegister(kRegRasterizerControl, ULWord(inIsEnabled), kRegMaskRasterLevelB, kRegShiftRasterLevelB);
669 }
670 
671 bool CNTV2Card::GetHDMIOutLevelBMode (bool & outIsEnabled)
672 {
673  return GetNumSupported(kDeviceGetHDMIVersion) > 1
674  && GetNumSupported(kDeviceGetNumHDMIVideoOutputs) > 0
675  && CNTV2DriverInterface::ReadRegister (kRegRasterizerControl, outIsEnabled, kRegMaskRasterLevelB, kRegShiftRasterLevelB);
676 }
677 
678 bool CNTV2Card::SetHDMIV2Mode (const NTV2HDMIV2Mode inMode)
679 {
680  return GetNumSupported(kDeviceGetHDMIVersion) > 1
681  && WriteRegister(kRegRasterizerControl, inMode, kRegMaskRasterMode, kRegShiftRasterMode);
682 }
683 
684 
685 bool CNTV2Card::GetHDMIV2Mode (NTV2HDMIV2Mode & outMode)
686 {
687  return GetNumSupported(kDeviceGetHDMIVersion) > 1
688  && CNTV2DriverInterface::ReadRegister(kRegRasterizerControl, outMode, kRegMaskRasterMode, kRegShiftRasterMode);
689 }
690 
691 
692 bool CNTV2Card::GetHDMIOutStatus (NTV2HDMIOutputStatus & outStatus, const NTV2Channel inWhichHDMIOut)
693 {
694  ULWord reg(kVRegHDMIOutStatus1), data(0);
695  outStatus.Clear();
696  if (GetNumSupported(kDeviceGetHDMIVersion) < 4)
697  return false; // must have HDMI version 4 or higher
698  if (!GetHDMIOutStatusReg(reg, inWhichHDMIOut))
699  return false;
700  if (!ReadRegister(reg, data))
701  return false; // ReadRegister failed
702  return outStatus.SetFromRegValue(data);
703 }
704 
705 
706 bool CNTV2Card::SetHDMIHDRGreenPrimaryX(const uint16_t inGreenPrimaryX, const NTV2Channel inWhichHDMIOut)
707 {
708  ULWord reg(kRegHDMIHDRGreenPrimary);
709  if(!NTV2_IS_VALID_HDR_PRIMARY(inGreenPrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
710  return false;
711  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrGreenXCh1, uint32_t(inGreenPrimaryX)))
712  return false;
713  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
714  return false;
715  return WriteRegister(reg, uint32_t(inGreenPrimaryX), kRegMaskHDMIHDRGreenPrimaryX, kRegShiftHDMIHDRGreenPrimaryX);
716 }
717 
718 bool CNTV2Card::GetHDMIHDRGreenPrimaryX(uint16_t & outGreenPrimaryX, const NTV2Channel inWhichHDMIOut)
719 {
720  ULWord reg(kRegHDMIHDRGreenPrimary);
721  if (!IsSupported(kDeviceCanDoHDMIHDROut))
722  return false;
723  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
724  return false;
725  return CNTV2DriverInterface::ReadRegister(reg, outGreenPrimaryX, kRegMaskHDMIHDRGreenPrimaryX, kRegShiftHDMIHDRGreenPrimaryX);
726 }
727 
728 bool CNTV2Card::SetHDMIHDRGreenPrimaryY(const uint16_t inGreenPrimaryY, const NTV2Channel inWhichHDMIOut)
729 {
730  ULWord reg(kRegHDMIHDRGreenPrimary);
731  if (!NTV2_IS_VALID_HDR_PRIMARY(inGreenPrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
732  return false;
733  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrGreenYCh1, uint32_t(inGreenPrimaryY)))
734  return false;
735  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
736  return false;
737  return WriteRegister(reg, uint32_t(inGreenPrimaryY), kRegMaskHDMIHDRGreenPrimaryY, kRegShiftHDMIHDRGreenPrimaryY);
738 }
739 
740 bool CNTV2Card::GetHDMIHDRGreenPrimaryY(uint16_t & outGreenPrimaryY, const NTV2Channel inWhichHDMIOut)
741 {
742  ULWord reg(kRegHDMIHDRGreenPrimary);
743  if (!IsSupported(kDeviceCanDoHDMIHDROut))
744  return false;
745  if (!GetHDMIOutHDRGreenPrimaryReg(reg, inWhichHDMIOut))
746  return false;
747  return CNTV2DriverInterface::ReadRegister(reg, outGreenPrimaryY, kRegMaskHDMIHDRGreenPrimaryY, kRegShiftHDMIHDRGreenPrimaryY);
748 }
749 
750 bool CNTV2Card::SetHDMIHDRBluePrimaryX(const uint16_t inBluePrimaryX, const NTV2Channel inWhichHDMIOut)
751 {
752  ULWord reg(kRegHDMIHDRBluePrimary);
753  if (!NTV2_IS_VALID_HDR_PRIMARY(inBluePrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
754  return false;
755  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrBlueXCh1, uint32_t(inBluePrimaryX)))
756  return false;
757  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
758  return false;
759  return WriteRegister(reg, uint32_t(inBluePrimaryX), kRegMaskHDMIHDRBluePrimaryX, kRegShiftHDMIHDRBluePrimaryX);
760 }
761 
762 bool CNTV2Card::GetHDMIHDRBluePrimaryX(uint16_t & outBluePrimaryX, const NTV2Channel inWhichHDMIOut)
763 {
764  ULWord reg(kRegHDMIHDRBluePrimary);
765  if (!IsSupported(kDeviceCanDoHDMIHDROut))
766  return false;
767  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
768  return false;
769  return CNTV2DriverInterface::ReadRegister(reg, outBluePrimaryX, kRegMaskHDMIHDRBluePrimaryX, kRegShiftHDMIHDRBluePrimaryX);
770 }
771 
772 bool CNTV2Card::SetHDMIHDRBluePrimaryY(const uint16_t inBluePrimaryY, const NTV2Channel inWhichHDMIOut)
773 {
774  ULWord reg(kRegHDMIHDRBluePrimary);
775  if (!NTV2_IS_VALID_HDR_PRIMARY(inBluePrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
776  return false;
777  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrBlueYCh1, uint32_t(inBluePrimaryY)))
778  return false;
779  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
780  return false;
781  return WriteRegister(reg, uint32_t(inBluePrimaryY), kRegMaskHDMIHDRBluePrimaryY, kRegShiftHDMIHDRBluePrimaryY);
782 }
783 
784 bool CNTV2Card::GetHDMIHDRBluePrimaryY(uint16_t & outBluePrimaryY, const NTV2Channel inWhichHDMIOut)
785 {
786  ULWord reg(kRegHDMIHDRBluePrimary);
787  if (!IsSupported(kDeviceCanDoHDMIHDROut))
788  return false;
789  if (!GetHDMIOutHDRBluePrimaryReg(reg, inWhichHDMIOut))
790  return false;
791  return CNTV2DriverInterface::ReadRegister(reg, outBluePrimaryY, kRegMaskHDMIHDRBluePrimaryY, kRegShiftHDMIHDRBluePrimaryY);
792 }
793 
794 bool CNTV2Card::SetHDMIHDRRedPrimaryX(const uint16_t inRedPrimaryX, const NTV2Channel inWhichHDMIOut)
795 {
796  ULWord reg(kRegHDMIHDRRedPrimary);
797  if (!NTV2_IS_VALID_HDR_PRIMARY(inRedPrimaryX) || !IsSupported(kDeviceCanDoHDMIHDROut))
798  return false;
799  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrRedXCh1, uint32_t(inRedPrimaryX)))
800  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
801  return false;
802  return WriteRegister(reg, uint32_t(inRedPrimaryX), kRegMaskHDMIHDRRedPrimaryX, kRegShiftHDMIHDRRedPrimaryX);
803 }
804 
805 bool CNTV2Card::GetHDMIHDRRedPrimaryX(uint16_t & outRedPrimaryX, const NTV2Channel inWhichHDMIOut)
806 {
807  ULWord reg(kRegHDMIHDRRedPrimary);
808  if (!IsSupported(kDeviceCanDoHDMIHDROut))
809  return false;
810  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
811  return false;
812  return CNTV2DriverInterface::ReadRegister(reg, outRedPrimaryX, kRegMaskHDMIHDRRedPrimaryX, kRegShiftHDMIHDRRedPrimaryX);
813 }
814 
815 bool CNTV2Card::SetHDMIHDRRedPrimaryY(const uint16_t inRedPrimaryY, const NTV2Channel inWhichHDMIOut)
816 {
817  ULWord reg(kRegHDMIHDRRedPrimary);
818  if (!NTV2_IS_VALID_HDR_PRIMARY(inRedPrimaryY) || !IsSupported(kDeviceCanDoHDMIHDROut))
819  return false;
820  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrRedYCh1, uint32_t(inRedPrimaryY)))
821  return false;
822  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
823  return false;
824  return WriteRegister(reg, uint32_t(inRedPrimaryY), kRegMaskHDMIHDRRedPrimaryY, kRegShiftHDMIHDRRedPrimaryY);
825 }
826 
827 bool CNTV2Card::GetHDMIHDRRedPrimaryY(uint16_t & outRedPrimaryY, const NTV2Channel inWhichHDMIOut)
828 {
829  ULWord reg(kRegHDMIHDRRedPrimary);
830  if (!IsSupported(kDeviceCanDoHDMIHDROut))
831  return false;
832  if (!GetHDMIOutHDRRedPrimaryReg(reg, inWhichHDMIOut))
833  return false;
834  return CNTV2DriverInterface::ReadRegister(reg, outRedPrimaryY, kRegMaskHDMIHDRRedPrimaryY, kRegShiftHDMIHDRRedPrimaryY);
835 }
836 
837 bool CNTV2Card::SetHDMIHDRWhitePointX(const uint16_t inWhitePointX, const NTV2Channel inWhichHDMIOut)
838 {
839  ULWord reg(kRegHDMIHDRWhitePoint);
840  if (!NTV2_IS_VALID_HDR_PRIMARY(inWhitePointX) || !IsSupported(kDeviceCanDoHDMIHDROut))
841  return false;
842  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrWhiteXCh1, uint32_t(inWhitePointX)))
843  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
844  return false;
845  return WriteRegister(reg, uint32_t(inWhitePointX), kRegMaskHDMIHDRWhitePointX, kRegShiftHDMIHDRWhitePointX);
846 }
847 
848 bool CNTV2Card::GetHDMIHDRWhitePointX(uint16_t & outWhitePointX, const NTV2Channel inWhichHDMIOut)
849 {
850  ULWord reg(kRegHDMIHDRWhitePoint);
851  if (!IsSupported(kDeviceCanDoHDMIHDROut))
852  return false;
853  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
854  return false;
855  return CNTV2DriverInterface::ReadRegister(reg, outWhitePointX, kRegMaskHDMIHDRWhitePointX, kRegShiftHDMIHDRWhitePointX);
856 }
857 
858 bool CNTV2Card::SetHDMIHDRWhitePointY(const uint16_t inWhitePointY, const NTV2Channel inWhichHDMIOut)
859 {
860  ULWord reg(kRegHDMIHDRWhitePoint);
861  if (!NTV2_IS_VALID_HDR_PRIMARY(inWhitePointY) || !IsSupported(kDeviceCanDoHDMIHDROut))
862  return false;
863  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrWhiteYCh1, uint32_t(inWhitePointY)))
864  return false;
865  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
866  return false;
867  return WriteRegister(reg, uint32_t(inWhitePointY), kRegMaskHDMIHDRWhitePointY, kRegShiftHDMIHDRWhitePointY);
868 }
869 
870 bool CNTV2Card::GetHDMIHDRWhitePointY(uint16_t & outWhitePointY, const NTV2Channel inWhichHDMIOut)
871 {
872  ULWord reg(kRegHDMIHDRWhitePoint);
873  if (!IsSupported(kDeviceCanDoHDMIHDROut))
874  return false;
875  if (!GetHDMIOutHDRWhitePointReg(reg, inWhichHDMIOut))
876  return false;
877  return CNTV2DriverInterface::ReadRegister(reg, outWhitePointY, kRegMaskHDMIHDRWhitePointY, kRegShiftHDMIHDRWhitePointY);
878 }
879 
880 bool CNTV2Card::SetHDMIHDRMaxMasteringLuminance(const uint16_t inMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut)
881 {
882  ULWord reg(kRegHDMIHDRMasteringLuminence);
883  if (!NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(inMaxMasteringLuminance) || !IsSupported(kDeviceCanDoHDMIHDROut))
884  return false;
885  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMasterLumMaxCh1, uint32_t(inMaxMasteringLuminance)))
886  return false;
887  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
888  return false;
889  return WriteRegister(reg, uint32_t(inMaxMasteringLuminance), kRegMaskHDMIHDRMaxMasteringLuminance, kRegShiftHDMIHDRMaxMasteringLuminance);
890 }
891 
892 bool CNTV2Card::GetHDMIHDRMaxMasteringLuminance(uint16_t & outMaxMasteringLuminance, const NTV2Channel inWhichHDMIOut)
893 {
894  ULWord reg(kRegHDMIHDRMasteringLuminence);
895  if (!IsSupported(kDeviceCanDoHDMIHDROut))
896  return false;
897  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
898  return false;
899  return CNTV2DriverInterface::ReadRegister(reg, outMaxMasteringLuminance, kRegMaskHDMIHDRMaxMasteringLuminance, kRegShiftHDMIHDRMaxMasteringLuminance);
900 }
901 
902 bool CNTV2Card::SetHDMIHDRMinMasteringLuminance(const uint16_t inMinMasteringLuminance, const NTV2Channel inWhichHDMIOut)
903 {
904  ULWord reg(kRegHDMIHDRMasteringLuminence);
905  if (!NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(inMinMasteringLuminance) || !IsSupported(kDeviceCanDoHDMIHDROut))
906  return false;
907  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMasterLumMinCh1, uint32_t(inMinMasteringLuminance)))
908  return false;
909  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
910  return false;
911  return WriteRegister(reg, uint32_t(inMinMasteringLuminance), kRegMaskHDMIHDRMinMasteringLuminance, kRegShiftHDMIHDRMinMasteringLuminance);
912 }
913 
914 bool CNTV2Card::GetHDMIHDRMinMasteringLuminance(uint16_t & outMinMasteringLuminance, const NTV2Channel inWhichHDMIOut)
915 {
916  ULWord reg(kRegHDMIHDRMasteringLuminence);
917  if (!IsSupported(kDeviceCanDoHDMIHDROut))
918  return false;
919  if (!GetHDMIOutHDRMasterLuminanceReg(reg, inWhichHDMIOut))
920  return false;
921  return CNTV2DriverInterface::ReadRegister(reg, outMinMasteringLuminance, kRegMaskHDMIHDRMinMasteringLuminance, kRegShiftHDMIHDRMinMasteringLuminance);
922 }
923 
924 bool CNTV2Card::SetHDMIHDRMaxContentLightLevel(const uint16_t inMaxContentLightLevel, const NTV2Channel inWhichHDMIOut)
925 {
926  ULWord reg(kRegHDMIHDRLightLevel);
927  if (!NTV2_IS_VALID_HDR_LIGHT_LEVEL(inMaxContentLightLevel) || !IsSupported(kDeviceCanDoHDMIHDROut))
928  return false;
929  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMaxCLLCh1, uint32_t(inMaxContentLightLevel)))
930  return false;
931  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
932  return false;
933  return WriteRegister(reg, uint32_t(inMaxContentLightLevel), kRegMaskHDMIHDRMaxContentLightLevel, kRegShiftHDMIHDRMaxContentLightLevel);
934 }
935 
936 bool CNTV2Card::GetHDMIHDRMaxContentLightLevel(uint16_t & outMaxContentLightLevel, const NTV2Channel inWhichHDMIOut)
937 {
938  ULWord reg(kRegHDMIHDRLightLevel);
939  if (!IsSupported(kDeviceCanDoHDMIHDROut))
940  return false;
941  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
942  return false;
943  return CNTV2DriverInterface::ReadRegister(reg, outMaxContentLightLevel, kRegMaskHDMIHDRMaxContentLightLevel, kRegShiftHDMIHDRMaxContentLightLevel);
944 }
945 
946 bool CNTV2Card::SetHDMIHDRMaxFrameAverageLightLevel(const uint16_t inMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut)
947 {
948  ULWord reg(kRegHDMIHDRLightLevel);
949  if(!NTV2_IS_VALID_HDR_LIGHT_LEVEL(inMaxFrameAverageLightLevel) || !IsSupported(kDeviceCanDoHDMIHDROut))
950  return false;
951  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrMaxFALLCh1, uint32_t(inMaxFrameAverageLightLevel)))
952  return false;
953  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
954  return false;
955  return WriteRegister(reg, uint32_t(inMaxFrameAverageLightLevel), kRegMaskHDMIHDRMaxFrameAverageLightLevel, kRegShiftHDMIHDRMaxFrameAverageLightLevel);
956 }
957 
958 bool CNTV2Card::GetHDMIHDRMaxFrameAverageLightLevel(uint16_t & outMaxFrameAverageLightLevel, const NTV2Channel inWhichHDMIOut)
959 {
960  ULWord reg(kRegHDMIHDRLightLevel);
961  if (!IsSupported(kDeviceCanDoHDMIHDROut))
962  return false;
963  if (!GetHDMIOutHDRLightLevelReg(reg, inWhichHDMIOut))
964  return false;
965  return CNTV2DriverInterface::ReadRegister(reg, outMaxFrameAverageLightLevel, kRegMaskHDMIHDRMaxFrameAverageLightLevel, kRegShiftHDMIHDRMaxFrameAverageLightLevel);
966 }
967 
968 bool CNTV2Card::SetHDMIHDRConstantLuminance(const bool inEnableConstantLuminance, const NTV2Channel inWhichHDMIOut)
969 {
970  ULWord reg(kRegHDMIHDRControl);
971  if (!IsSupported(kDeviceCanDoHDMIHDROut))
972  return false;
973  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrLuminanceCh1, inEnableConstantLuminance ? 1 : 0))
974  return false;
975  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
976  return false;
977  return WriteRegister(reg, inEnableConstantLuminance ? 1 : 0, kRegMaskHDMIHDRNonContantLuminance, kRegShiftHDMIHDRNonContantLuminance);
978 }
979 
980 bool CNTV2Card::GetHDMIHDRConstantLuminance(const NTV2Channel inWhichHDMIOut)
981 {
982  ULWord reg(kRegHDMIHDRControl);
983  if (!IsSupported(kDeviceCanDoHDMIHDROut))
984  return false;
985  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
986  return false;
987  uint32_t regValue = 0;
988  ReadRegister(reg, regValue, kRegMaskHDMIHDRNonContantLuminance, kRegShiftHDMIHDRNonContantLuminance);
989  return regValue ? true : false;
990 }
991 
992 bool CNTV2Card::SetHDMIHDRElectroOpticalTransferFunction(const uint8_t inEOTFByte, const NTV2Channel inWhichHDMIOut)
993 {
994  ULWord reg(kRegHDMIHDRControl);
995  if (!IsSupported(kDeviceCanDoHDMIHDROut))
996  return false;
997  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrTransferCh1, inEOTFByte))
998  return false;
999  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1000  return false;
1001  return WriteRegister(reg, inEOTFByte, kRegMaskElectroOpticalTransferFunction, kRegShiftElectroOpticalTransferFunction);
1002 }
1003 
1004 bool CNTV2Card::GetHDMIHDRElectroOpticalTransferFunction(uint8_t & outEOTFByte, const NTV2Channel inWhichHDMIOut)
1005 {
1006  ULWord reg(kRegHDMIHDRControl);
1007  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1008  return false;
1009  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1010  return false;
1011  return CNTV2DriverInterface::ReadRegister(reg, outEOTFByte, kRegMaskElectroOpticalTransferFunction, kRegShiftElectroOpticalTransferFunction);
1012 }
1013 
1014 bool CNTV2Card::SetHDMIHDRStaticMetadataDescriptorID(const uint8_t inSMDId, const NTV2Channel inWhichHDMIOut)
1015 {
1016  ULWord reg(kRegHDMIHDRControl);
1017  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1018  return false;
1019  if (inWhichHDMIOut == NTV2_CHANNEL1 && !WriteRegister(kVRegHdrColorimetryCh1, uint32_t(inSMDId)))
1020  return false;
1021  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1022  return false;
1023  return WriteRegister(reg, uint32_t(inSMDId), kRegMaskHDRStaticMetadataDescriptorID, kRegShiftHDRStaticMetadataDescriptorID);
1024 }
1025 
1026 bool CNTV2Card::GetHDMIHDRStaticMetadataDescriptorID(uint8_t & outSMDId, const NTV2Channel inWhichHDMIOut)
1027 {
1028  ULWord reg(kRegHDMIHDRControl);
1029  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1030  return false;
1031  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1032  return false;
1033  return CNTV2DriverInterface::ReadRegister(reg, outSMDId, kRegMaskHDRStaticMetadataDescriptorID, kRegShiftHDRStaticMetadataDescriptorID);
1034 }
1035 
1036 bool CNTV2Card::EnableHDMIHDR(const bool inEnableHDMIHDR, const NTV2Channel inWhichHDMIOut)
1037 {
1038  ULWord reg(kRegHDMIHDRControl);
1039  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1040  return false;
1041  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1042  return false;
1043 
1044  bool status = WriteRegister(reg, inEnableHDMIHDR ? 1 : 0, kRegMaskHDMIHDREnable, kRegShiftHDMIHDREnable);
1045  if (GetNumSupported(kDeviceGetHDMIVersion) < 6)
1046  WaitForOutputFieldID(NTV2_FIELD0, NTV2_CHANNEL1);
1047  return status;
1048 }
1049 
1050 bool CNTV2Card::GetHDMIHDREnabled (const NTV2Channel inWhichHDMIOut)
1051 {
1052  ULWord reg(kRegHDMIHDRControl);
1053  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1054  return false;
1055  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1056  return false;
1057 
1058  uint32_t regValue = 0;
1059  ReadRegister(reg, regValue, kRegMaskHDMIHDREnable, kRegShiftHDMIHDREnable);
1060  return regValue ? true : false;
1061 }
1062 
1063 bool CNTV2Card::EnableHDMIHDRDolbyVision(const bool inEnable, const NTV2Channel inWhichHDMIOut)
1064 {
1065  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1066  return false;
1067  ULWord reg(kRegHDMIHDRControl);
1068  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1069  return false;
1070 
1071  bool status = WriteRegister(reg, inEnable ? 1 : 0, kRegMaskHDMIHDRDolbyVisionEnable, kRegShiftHDMIHDRDolbyVisionEnable);
1072  if (GetNumSupported(kDeviceGetHDMIVersion) < 6)
1073  WaitForOutputFieldID(NTV2_FIELD0, NTV2_CHANNEL1);
1074  return status;
1075 }
1076 
1077 bool CNTV2Card::GetHDMIHDRDolbyVisionEnabled (const NTV2Channel inWhichHDMIOut)
1078 {
1079  if (!IsSupported(kDeviceCanDoHDMIHDROut))
1080  return false;
1081  ULWord reg(kRegHDMIHDRControl);
1082  if (!GetHDMIOutHDRControlReg(reg, inWhichHDMIOut))
1083  return false;
1084 
1085  bool enabled(false);
1086  return driverInterface().ReadRegister(reg, enabled, kRegMaskHDMIHDRDolbyVisionEnable, kRegShiftHDMIHDRDolbyVisionEnable) ? enabled : false;
1087 }
1088 
1089 bool CNTV2Card::SetHDRData (const HDRFloatValues & inFloatValues, const NTV2Channel inWhichHDMIOut)
1090 {
1091  HDRRegValues regValues;
1092  return inFloatValues.toRegValues(regValues) && SetHDRData(regValues, inWhichHDMIOut);
1093 }
1094 
1095 bool CNTV2Card::SetHDRData (const HDRRegValues & inRegisterValues, const NTV2Channel inWhichHDMIOut)
1096 {
1097  return SetHDMIHDRGreenPrimaryX(inRegisterValues.greenPrimaryX, inWhichHDMIOut)
1098  && SetHDMIHDRGreenPrimaryY(inRegisterValues.greenPrimaryY, inWhichHDMIOut)
1099  && SetHDMIHDRBluePrimaryX(inRegisterValues.bluePrimaryX, inWhichHDMIOut)
1100  && SetHDMIHDRBluePrimaryY(inRegisterValues.bluePrimaryY, inWhichHDMIOut)
1101  && SetHDMIHDRRedPrimaryX(inRegisterValues.redPrimaryX, inWhichHDMIOut)
1102  && SetHDMIHDRRedPrimaryY(inRegisterValues.redPrimaryY, inWhichHDMIOut)
1103  && SetHDMIHDRWhitePointX(inRegisterValues.whitePointX, inWhichHDMIOut)
1104  && SetHDMIHDRWhitePointY(inRegisterValues.whitePointY, inWhichHDMIOut)
1105  && SetHDMIHDRMaxMasteringLuminance(inRegisterValues.maxMasteringLuminance, inWhichHDMIOut)
1106  && SetHDMIHDRMinMasteringLuminance(inRegisterValues.minMasteringLuminance, inWhichHDMIOut)
1107  && SetHDMIHDRMaxContentLightLevel(inRegisterValues.maxContentLightLevel, inWhichHDMIOut)
1108  && SetHDMIHDRMaxFrameAverageLightLevel(inRegisterValues.maxFrameAverageLightLevel, inWhichHDMIOut)
1109  && SetHDMIHDRElectroOpticalTransferFunction(inRegisterValues.electroOpticalTransferFunction, inWhichHDMIOut)
1110  && SetHDMIHDRStaticMetadataDescriptorID(inRegisterValues.staticMetadataDescriptorID, inWhichHDMIOut);
1111 }
1112 
1113 bool CNTV2Card::GetHDRData (HDRFloatValues & outFloatValues, const NTV2Channel inWhichHDMIOut)
1114 {
1115  HDRRegValues regValues;
1116  return GetHDRData(regValues, inWhichHDMIOut) && outFloatValues.setFromRegValues(regValues);
1117 }
1118 
1119 bool CNTV2Card::GetHDRData (HDRRegValues & outRegisterValues, const NTV2Channel inWhichHDMIOut)
1120 {
1121  return GetHDMIHDRGreenPrimaryX(outRegisterValues.greenPrimaryX, inWhichHDMIOut)
1122  && GetHDMIHDRGreenPrimaryY(outRegisterValues.greenPrimaryY, inWhichHDMIOut)
1123  && GetHDMIHDRBluePrimaryX(outRegisterValues.bluePrimaryX, inWhichHDMIOut)
1124  && GetHDMIHDRBluePrimaryY(outRegisterValues.bluePrimaryY, inWhichHDMIOut)
1125  && GetHDMIHDRRedPrimaryX(outRegisterValues.redPrimaryX, inWhichHDMIOut)
1126  && GetHDMIHDRRedPrimaryY(outRegisterValues.redPrimaryY, inWhichHDMIOut)
1127  && GetHDMIHDRWhitePointX(outRegisterValues.whitePointX, inWhichHDMIOut)
1128  && GetHDMIHDRWhitePointY(outRegisterValues.whitePointY, inWhichHDMIOut)
1129  && GetHDMIHDRMaxMasteringLuminance(outRegisterValues.maxMasteringLuminance, inWhichHDMIOut)
1130  && GetHDMIHDRMinMasteringLuminance(outRegisterValues.minMasteringLuminance, inWhichHDMIOut)
1131  && GetHDMIHDRMaxContentLightLevel(outRegisterValues.maxContentLightLevel, inWhichHDMIOut)
1132  && GetHDMIHDRMaxFrameAverageLightLevel(outRegisterValues.maxFrameAverageLightLevel, inWhichHDMIOut)
1133  && GetHDMIHDRElectroOpticalTransferFunction(outRegisterValues.electroOpticalTransferFunction, inWhichHDMIOut)
1134  && GetHDMIHDRStaticMetadataDescriptorID(outRegisterValues.staticMetadataDescriptorID, inWhichHDMIOut);
1135 }
1136 
1137 bool CNTV2Card::SetHDMIHDRBT2020(const NTV2Channel inWhichHDMIOut)
1138 {
1139  HDRRegValues regValues;
1140  regValues.setBT2020();
1141  EnableHDMIHDR(false, inWhichHDMIOut);
1142  SetHDRData(regValues, inWhichHDMIOut);
1143  EnableHDMIHDR(true, inWhichHDMIOut);
1144  return true;
1145 }
1146 
1147 bool CNTV2Card::SetHDMIHDRDCIP3(const NTV2Channel inWhichHDMIOut)
1148 {
1149  HDRRegValues regValues;
1150  regValues.setDCIP3();
1151  EnableHDMIHDR(false, inWhichHDMIOut);
1152  SetHDRData(regValues, inWhichHDMIOut);
1153  EnableHDMIHDR(true, inWhichHDMIOut);
1154  return true;
1155 }
1156 
1157 bool CNTV2Card::GetHDMIOutAudioChannel34Swap (bool & outIsSwapped, const NTV2Channel inWhichHDMIOut)
1158 {
1159  outIsSwapped = false;
1160  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1161  return false;
1162  ULWord reg(kRegHDMIInputControl);
1163  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1164  return false;
1165  return CNTV2DriverInterface::ReadRegister(reg, outIsSwapped, kRegMaskHDMISwapOutputAudCh34, kRegShiftHDMISwapOutputAudCh34);
1166 }
1167 
1168 bool CNTV2Card::SetHDMIOutAudioChannel34Swap (const bool inIsSwapped, const NTV2Channel inWhichHDMIOut)
1169 {
1170  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1171  return false;
1172  ULWord reg(kRegHDMIInputControl);
1173  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1174  return false;
1175  return WriteRegister(reg, inIsSwapped ? 1 : 0, kRegMaskHDMISwapOutputAudCh34, kRegShiftHDMISwapOutputAudCh34);
1176 }
1177 
1178 bool CNTV2Card::EnableHDMIOutUserOverride (bool enable, const NTV2Channel inWhichHDMIOut)
1179 {
1180  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1181  return false;
1182  ULWord reg(kRegHDMIInputControl);
1183  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1184  return false;
1185  return WriteRegister(reg, enable ? 1 : 0, kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
1186 }
1187 
1188 bool CNTV2Card::GetEnableHDMIOutUserOverride (bool & isEnabled, const NTV2Channel inWhichHDMIOut)
1189 {
1190  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1191  return false;
1192  ULWord reg(kRegHDMIInputControl);
1193  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1194  return false;
1195  return driverInterface().ReadRegister(reg, isEnabled, kRegMaskHDMIOutForceConfig, kRegShiftHDMIOutForceConfig);
1196 }
1197 
1198 bool CNTV2Card::EnableHDMIOutCenterCrop (bool enable, const NTV2Channel inWhichHDMIOut)
1199 {
1200  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1201  return false;
1202  ULWord reg(kRegHDMIInputControl);
1203  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1204  return false;
1205  return WriteRegister(reg, enable ? 1 : 0, kRegMaskHDMIOutCropEnable, kRegShiftHDMIOutCropEnable);
1206 }
1207 
1208 bool CNTV2Card::GetEnableHDMIOutCenterCrop (bool & isEnabled, const NTV2Channel inWhichHDMIOut)
1209 {
1210  if (!GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1211  return false;
1212  ULWord reg(kRegHDMIInputControl);
1213  if (!GetHDMIOutInputControlRegNum(reg, inWhichHDMIOut))
1214  return false;
1215  return driverInterface().ReadRegister (reg, isEnabled, kRegMaskHDMIOutCropEnable, kRegShiftHDMIOutCropEnable);
1216 }
1217 
1218 bool CNTV2Card::GetHDMIOutControlReg (ULWord & outReg, const NTV2Channel inWhichHDMIOut)
1219 {
1220  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1221  return false;
1222  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1223  if (!hdmiVers)
1224  return false;
1225  outReg = hdmiVers < 6 ? ULWord(kRegHDMIOutControl) : gHDMIChannelToOutControlVRegNum[ULWord(inWhichHDMIOut)];
1226  return true;
1227 }
1228 
1229 bool CNTV2Card::GetHDMIOutInputStatusRegNum (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1230 {
1231  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1232  return false;
1233  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1234  if (!hdmiVers)
1235  return false;
1236  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIInputStatus) : gHDMIChannelToInputStatusVRegNum[ULWord(inWhichHDMIOut)];
1237  return true;
1238 }
1239 
1240 bool CNTV2Card::GetHDMIOutInputControlRegNum (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1241 {
1242  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1243  return false;
1244  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1245  if (!hdmiVers)
1246  return false;
1247  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIInputControl) : gHDMIChannelToInputControlVRegNum[ULWord(inWhichHDMIOut)];
1248  return true;
1249 }
1250 
1251 bool CNTV2Card::GetHDMIOutStatusReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1252 {
1253  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1254  return false;
1255  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1256  if (!hdmiVers)
1257  return false;
1258  outRegNum = hdmiVers < 6 ? ULWord(kVRegHDMIOutStatus1) : gHDMIChannelToOutStatusVRegNum[ULWord(inWhichHDMIOut)];
1259  return true;
1260 }
1261 
1262 bool CNTV2Card::GetHDMIOutHDRGreenPrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1263 {
1264  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1265  return false;
1266  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1267  if (!hdmiVers)
1268  return false;
1269  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRGreenPrimary) : gHDMIChannelToOutHDRGreenPrimaryVRegNum[ULWord(inWhichHDMIOut)];
1270  return true;
1271 }
1272 
1273 bool CNTV2Card::GetHDMIOutHDRBluePrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1274 {
1275  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1276  return false;
1277  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1278  if (!hdmiVers)
1279  return false;
1280  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRBluePrimary) : gHDMIChannelToOutHDRBluePrimaryVRegNum[ULWord(inWhichHDMIOut)];
1281  return true;
1282 }
1283 
1284 bool CNTV2Card::GetHDMIOutHDRRedPrimaryReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1285 {
1286  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1287  return false;
1288  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1289  if (!hdmiVers)
1290  return false;
1291  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRRedPrimary) : gHDMIChannelToOutHDRRedPrimaryVRegNum[ULWord(inWhichHDMIOut)];
1292  return true;
1293 }
1294 
1295 bool CNTV2Card::GetHDMIOutHDRWhitePointReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1296 {
1297  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1298  return false;
1299  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1300  if (!hdmiVers)
1301  return false;
1302  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRWhitePoint) : gHDMIChannelToOutHDRWhitePointVRegNum[ULWord(inWhichHDMIOut)];
1303  return true;
1304 }
1305 
1306 bool CNTV2Card::GetHDMIOutHDRMasterLuminanceReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1307 {
1308  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1309  return false;
1310  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1311  if (!hdmiVers)
1312  return false;
1313  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRMasteringLuminence) : gHDMIChannelToOutHDRMasterLuminanceVRegNum[ULWord(inWhichHDMIOut)];
1314  return true;
1315 }
1316 
1317 bool CNTV2Card::GetHDMIOutHDRLightLevelReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1318 {
1319  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1320  return false;
1321  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1322  if (!hdmiVers)
1323  return false;
1324  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRLightLevel) : gHDMIChannelToOutHDRLightLevelVRegNum[ULWord(inWhichHDMIOut)];
1325  return true;
1326 }
1327 
1328 bool CNTV2Card::GetHDMIOutHDRControlReg (ULWord & outRegNum, const NTV2Channel inWhichHDMIOut)
1329 {
1330  if (ULWord(inWhichHDMIOut) >= GetNumSupported(kDeviceGetNumHDMIVideoOutputs))
1331  return false;
1332  const ULWord hdmiVers (GetNumSupported(kDeviceGetHDMIVersion));
1333  if (!hdmiVers)
1334  return false;
1335  outRegNum = hdmiVers < 6 ? ULWord(kRegHDMIHDRControl) : gHDMIChannelToOutHDRControlVRegNum[ULWord(inWhichHDMIOut)];
1336  return true;
1337 }
1338 
1340 
1341 #ifdef MSWindows
1342 #pragma warning(default: 4800)
1343 #endif
kVRegHDMIOutControl3
@ kVRegHDMIOutControl3
Definition: ntv2virtualregisters.h:657
kVRegShiftHDMIInColorimetry
@ kVRegShiftHDMIInColorimetry
Definition: ntv2virtualregisters.h:771
CNTV2Card::GetHDMIOutHDRMasterLuminanceReg
virtual bool GetHDMIOutHDRMasterLuminanceReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1306
kRegHDMIControl2
@ kRegHDMIControl2
Definition: ntv2publicinterface.h:1039
kVRegHDMIOutHDRMasterLuminance2
@ kVRegHDMIOutHDRMasterLuminance2
Definition: ntv2virtualregisters.h:653
CNTV2Card::GetHDMIHDRStaticMetadataDescriptorID
virtual bool GetHDMIHDRStaticMetadataDescriptorID(uint8_t &outSMDId, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1026
HDRFloatValues::zero
HDRFloatValues & zero(void)
Definition: ntv2publicinterface.h:10255
kRegHDMIHDRControl
@ kRegHDMIHDRControl
Definition: ntv2publicinterface.h:489
HDRFloatValues::setFromRegValues
bool setFromRegValues(const HDRRegValues &inRegValues)
Definition: ntv2publicinterface.h:10269
DEVICE_ID_KONALHIDVI
@ DEVICE_ID_KONALHIDVI
See KONA LHi.
Definition: ntv2enums.h:77
kRegRasterizerControl
@ kRegRasterizerControl
Definition: ntv2publicinterface.h:521
kVRegHDMIInAviInfo2
@ kVRegHDMIInAviInfo2
Definition: ntv2virtualregisters.h:617
HDRRegValues::maxContentLightLevel
uint16_t maxContentLightLevel
Definition: ntv2publicinterface.h:10210
CNTV2Card::GetHDMIOutDisable
virtual bool GetHDMIOutDisable(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:611
kLHIRegMaskHDMIOutFPS
@ kLHIRegMaskHDMIOutFPS
Definition: ntv2publicinterface.h:1598
gHDMIChannelToOutControlVRegNum
static const ULWord gHDMIChannelToOutControlVRegNum[]
Definition: ntv2hdmi.cpp:24
kVRegHdrMasterLumMaxCh1
@ kVRegHdrMasterLumMaxCh1
Definition: ntv2virtualregisters.h:547
kRegShiftHDRStaticMetadataDescriptorID
@ kRegShiftHDRStaticMetadataDescriptorID
Definition: ntv2publicinterface.h:3283
kVRegHDMIInDrmBluePrimary1
@ kVRegHDMIInDrmBluePrimary1
Definition: ntv2virtualregisters.h:612
CNTV2Card::GetHDMIHDRElectroOpticalTransferFunction
virtual bool GetHDMIHDRElectroOpticalTransferFunction(uint8_t &outEOTFByte, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1004
CNTV2Card::GetHDMIOutTsiIO
virtual bool GetHDMIOutTsiIO(bool &tsiEnabled)
Definition: ntv2hdmi.cpp:657
kRegShiftHDMIHDRWhitePointY
@ kRegShiftHDMIHDRWhitePointY
Definition: ntv2publicinterface.h:3273
kVRegHdrBlueYCh1
@ kVRegHdrBlueYCh1
Definition: ntv2virtualregisters.h:542
HDRRegValues::whitePointX
uint16_t whitePointX
Definition: ntv2publicinterface.h:10206
kRegHDMIHDRWhitePoint
@ kRegHDMIHDRWhitePoint
Definition: ntv2publicinterface.h:486
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:880
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....
Definition: ntv2hdmi.cpp:827
kVRegHDMIOutHDRGreenPrimary4
@ kVRegHDMIOutHDRGreenPrimary4
Definition: ntv2virtualregisters.h:673
kRegShiftHDMIOutRange
@ kRegShiftHDMIOutRange
Definition: ntv2publicinterface.h:2695
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::GetHDMIInDynamicRange
virtual bool GetHDMIInDynamicRange(HDRRegValues &outRegValues, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's video dynamic range and mastering information.
Definition: ntv2hdmi.cpp:88
kVRegHDMIOutHDRWhitePoint3
@ kVRegHDMIOutHDRWhitePoint3
Definition: ntv2virtualregisters.h:664
DEVICE_ID_KONAHDMI
@ DEVICE_ID_KONAHDMI
See KONA HDMI.
Definition: ntv2enums.h:66
CNTV2Card::GetHDMIInAudioSampleRateConverterEnable
virtual bool GetHDMIInAudioSampleRateConverterEnable(bool &outIsEnabled, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:269
kRegMaskRasterLevelB
@ kRegMaskRasterLevelB
Definition: ntv2publicinterface.h:2113
NTV2HDMIBitDepth
NTV2HDMIBitDepth
Indicates or specifies the HDMI video bit depth.
Definition: ntv2enums.h:3670
kVRegHDMIInputControl2
@ kVRegHDMIInputControl2
Definition: ntv2virtualregisters.h:647
NTV2_CHANNEL2
@ NTV2_CHANNEL2
Specifies channel or FrameStore 2 (or the 2nd item).
Definition: ntv2enums.h:1349
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
kVRegHDMIOutControl2
@ kVRegHDMIOutControl2
Definition: ntv2virtualregisters.h:645
CNTV2Card::GetHDMIOutHDRBluePrimaryReg
virtual bool GetHDMIOutHDRBluePrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1273
NTV2_HDMIAudio2Channels
@ NTV2_HDMIAudio2Channels
2 audio channels
Definition: ntv2enums.h:3647
kRegShiftHDMIHDRGreenPrimaryX
@ kRegShiftHDMIHDRGreenPrimaryX
Definition: ntv2publicinterface.h:3266
ntv2devicefeatures.h
Declares device capability functions.
NTV2LHIHDMIColorSpace
NTV2LHIHDMIColorSpace
Definition: ntv2enums.h:3656
kRegShiftHDMISampling
@ kRegShiftHDMISampling
Definition: ntv2publicinterface.h:2691
HDRRegValues::setDCIP3
HDRRegValues & setDCIP3(void)
Definition: ntv2publicinterface.h:10229
kVRegHDMIOutHDRGreenPrimary3
@ kVRegHDMIOutHDRGreenPrimary3
Definition: ntv2virtualregisters.h:661
kVRegHDMIOutStatus1
@ kVRegHDMIOutStatus1
Definition: ntv2virtualregisters.h:626
kRegMaskHDMIOutForceConfig
@ kRegMaskHDMIOutForceConfig
Definition: ntv2publicinterface.h:1633
CNTV2Card::GetHDMIInAudioChannel34Swap
virtual bool GetHDMIInAudioChannel34Swap(bool &outIsSwapped, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's current audio channel 3/4 swap setting.
Definition: ntv2hdmi.cpp:294
kRegMaskHDMIHDRBluePrimaryY
@ kRegMaskHDMIHDRBluePrimaryY
Definition: ntv2publicinterface.h:2207
HDRRegValues::redPrimaryY
uint16_t redPrimaryY
Definition: ntv2publicinterface.h:10205
HDRFloatValues
Definition: ntv2publicinterface.h:10237
kRegMaskHDMIHDREnable
@ kRegMaskHDMIHDREnable
Definition: ntv2publicinterface.h:2219
NTV2_HDMIColorimetryNoData
@ NTV2_HDMIColorimetryNoData
Definition: ntv2enums.h:3629
kVRegHDMIOutHDRRedPrimary1
@ kVRegHDMIOutHDRRedPrimary1
Definition: ntv2virtualregisters.h:639
NTV2Channel
NTV2Channel
These enum values are mostly used to identify a specific widget_framestore. They're also commonly use...
Definition: ntv2enums.h:1346
NTV2HDMIColorSpace
NTV2HDMIColorSpace
Indicates or specifies HDMI Color Space.
Definition: ntv2enums.h:3583
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:837
kRegShiftHDMIOutVideoStd
@ kRegShiftHDMIOutVideoStd
Definition: ntv2publicinterface.h:2681
kLHIRegMaskHDMIInputProtocol
@ kLHIRegMaskHDMIInputProtocol
Definition: ntv2publicinterface.h:1629
kRegMaskHDMIHDRRedPrimaryX
@ kRegMaskHDMIHDRRedPrimaryX
Definition: ntv2publicinterface.h:2208
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:1208
kVRegHDMIInDrmRedPrimary1
@ kVRegHDMIInDrmRedPrimary1
Definition: ntv2virtualregisters.h:613
gHDMIChannelToOutHDRBluePrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRBluePrimaryVRegNum[]
Definition: ntv2hdmi.cpp:36
NTV2_STANDARD_INVALID
@ NTV2_STANDARD_INVALID
Definition: ntv2enums.h:179
kRegShiftHDMIOutForceConfig
@ kRegShiftHDMIOutForceConfig
Definition: ntv2publicinterface.h:2718
kVRegHDMIOutStatus3
@ kVRegHDMIOutStatus3
Definition: ntv2virtualregisters.h:660
gHDMIChannelToControlRegNum
static const ULWord gHDMIChannelToControlRegNum[]
Definition: ntv2hdmi.cpp:21
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:740
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
CNTV2Card::GetHDMIOutHDRGreenPrimaryReg
virtual bool GetHDMIOutHDRGreenPrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1262
HDRRegValues::bluePrimaryX
uint16_t bluePrimaryX
Definition: ntv2publicinterface.h:10202
kRegMaskHDMIHDRGreenPrimaryX
@ kRegMaskHDMIHDRGreenPrimaryX
Definition: ntv2publicinterface.h:2204
kRegMaskHDMIHDRMaxMasteringLuminance
@ kRegMaskHDMIHDRMaxMasteringLuminance
Definition: ntv2publicinterface.h:2212
CNTV2Card::GetHDMIOutAudioChannel34Swap
virtual bool GetHDMIOutAudioChannel34Swap(bool &outIsSwapped, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the HDMI output's current audio channel 3/4 swap setting.
Definition: ntv2hdmi.cpp:1157
kRegShiftHDMIHDRMaxContentLightLevel
@ kRegShiftHDMIHDRMaxContentLightLevel
Definition: ntv2publicinterface.h:3276
kRegShiftHDMIColorSpace
@ kRegShiftHDMIColorSpace
Definition: ntv2publicinterface.h:2737
gHDMIChannelToOutStatusVRegNum
static const ULWord gHDMIChannelToOutStatusVRegNum[]
Definition: ntv2hdmi.cpp:30
kRegHDMIHDRGreenPrimary
@ kRegHDMIHDRGreenPrimary
Definition: ntv2publicinterface.h:483
CNTV2Card::GetHDMIOutDecimateMode
virtual bool GetHDMIOutDecimateMode(bool &outIsEnabled)
Definition: ntv2hdmi.cpp:643
CNTV2Card::GetHDMIOut3DMode
virtual bool GetHDMIOut3DMode(NTV2HDMIOut3DMode &outValue)
Definition: ntv2hdmi.cpp:332
NTV2HDMIAudioChannels
NTV2HDMIAudioChannels
Indicates or specifies the HDMI audio channel count.
Definition: ntv2enums.h:3645
kVRegHDMIOutStatus2
@ kVRegHDMIOutStatus2
Definition: ntv2virtualregisters.h:648
kRegShiftHDMIV2TxBypass
@ kRegShiftHDMIV2TxBypass
Definition: ntv2publicinterface.h:2685
CNTV2Card::SetHDMIInBitDepth
virtual bool SetHDMIInBitDepth(const NTV2HDMIBitDepth inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input's bit depth.
Definition: ntv2hdmi.cpp:212
CNTV2Card::GetHDMIHDRDolbyVisionEnabled
virtual bool GetHDMIHDRDolbyVisionEnabled(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1077
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
kVRegHDMIOutHDRLightLevel4
@ kVRegHDMIOutHDRLightLevel4
Definition: ntv2virtualregisters.h:678
kRegHDMIControl3
@ kRegHDMIControl3
Definition: ntv2publicinterface.h:1042
kVRegHDMIOutHDRGreenPrimary2
@ kVRegHDMIOutHDRGreenPrimary2
Definition: ntv2virtualregisters.h:649
kRegMaskHDMIOut3DPresent
@ kRegMaskHDMIOut3DPresent
Definition: ntv2publicinterface.h:1589
kRegHDMIHDRBluePrimary
@ kRegHDMIHDRBluePrimary
Definition: ntv2publicinterface.h:484
CNTV2Card::SetHDMIHDRConstantLuminance
virtual bool SetHDMIHDRConstantLuminance(const bool inEnableConstantLuminance, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables BT.2020 Y'cC'bcC'rc versus BT.2020 Y'C'bC'r or R'G'B'.
Definition: ntv2hdmi.cpp:968
gHDMIChannelToInputStatusVRegNum
static const ULWord gHDMIChannelToInputStatusVRegNum[]
Definition: ntv2hdmi.cpp:26
CNTV2Card::GetHDMIOutHDRWhitePointReg
virtual bool GetHDMIOutHDRWhitePointReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1295
CNTV2Card::SetHDMIInAudioSampleRateConverterEnable
virtual bool SetHDMIInAudioSampleRateConverterEnable(const bool inNewValue, const NTV2Channel inChannel=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:261
gHDMIChannelToInputControlVRegNum
static const ULWord gHDMIChannelToInputControlVRegNum[]
Definition: ntv2hdmi.cpp:28
kLHIRegShiftHDMIInputProtocol
@ kLHIRegShiftHDMIInputProtocol
Definition: ntv2publicinterface.h:2714
kRegMaskElectroOpticalTransferFunction
@ kRegMaskElectroOpticalTransferFunction
Definition: ntv2publicinterface.h:2220
kRegShiftHDMISampleRateConverterEnable
@ kRegShiftHDMISampleRateConverterEnable
Definition: ntv2publicinterface.h:2720
kRegMaskHDMIOutDisable
@ kRegMaskHDMIOutDisable
Definition: ntv2publicinterface.h:1612
kVRegHDMIOutHDRBluePrimary4
@ kVRegHDMIOutHDRBluePrimary4
Definition: ntv2virtualregisters.h:674
CNTV2Card::SetHDMIOutAudioChannel34Swap
virtual bool SetHDMIOutAudioChannel34Swap(const bool inIsSwapped, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Sets the HDMI output's audio channel 3/4 swap state.
Definition: ntv2hdmi.cpp:1168
kVRegHDMIInputControl1
@ kVRegHDMIInputControl1
Definition: ntv2virtualregisters.h:635
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:902
CNTV2Card::SetHDMIHDRDCIP3
virtual bool SetHDMIHDRDCIP3(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1147
CNTV2Card::SetHDMIInAudioChannel34Swap
virtual bool SetHDMIInAudioChannel34Swap(const bool inIsSwapped, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input's audio channel 3/4 swap state.
Definition: ntv2hdmi.cpp:304
NTV2_LHIHDMIColorSpaceRGB
@ NTV2_LHIHDMIColorSpaceRGB
Definition: ntv2enums.h:3659
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
NTV2_INVALID_HDMI_AUDIO_CHANNELS
@ NTV2_INVALID_HDMI_AUDIO_CHANNELS
Definition: ntv2enums.h:3650
CNTV2Card::EnableHDMIOutUserOverride
virtual bool EnableHDMIOutUserOverride(const bool inEnable, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables override of HDMI parameters.
Definition: ntv2hdmi.cpp:1178
kRegMaskHDMIVOBD
@ kRegMaskHDMIVOBD
Definition: ntv2publicinterface.h:1604
kRegMaskRasterMode
@ kRegMaskRasterMode
Definition: ntv2publicinterface.h:2111
NTV2_CHANNEL1
@ NTV2_CHANNEL1
Specifies channel or FrameStore 1 (or the first item).
Definition: ntv2enums.h:1348
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
kRegShiftHDMIHDRGreenPrimaryY
@ kRegShiftHDMIHDRGreenPrimaryY
Definition: ntv2publicinterface.h:3267
CNTV2Card::GetHDMIInColorSpace
virtual bool GetHDMIInColorSpace(NTV2HDMIColorSpace &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's current color space setting.
Definition: ntv2hdmi.cpp:203
NTV2HDMIOutputStatus::Clear
void Clear(void)
Resets me to an invalid state.
Definition: ntv2publicinterface.cpp:149
kRegShiftRasterLevelB
@ kRegShiftRasterLevelB
Definition: ntv2publicinterface.h:3175
kVRegHDMIInDrmLightLevel2
@ kVRegHDMIInDrmLightLevel2
Definition: ntv2virtualregisters.h:624
NTV2_FIELD0
@ 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:1831
kVRegHDMIInDrmInfo1
@ kVRegHDMIInDrmInfo1
Definition: ntv2virtualregisters.h:610
CNTV2Card::GetHDMIInputRange
virtual bool GetHDMIInputRange(NTV2HDMIRange &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's current input range setting.
Definition: ntv2hdmi.cpp:185
NTV2HDMIRange
NTV2HDMIRange
Indicates or specifies the HDMI RGB range.
Definition: ntv2enums.h:3613
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
kVRegHDMIInDrmBluePrimary2
@ kVRegHDMIInDrmBluePrimary2
Definition: ntv2virtualregisters.h:620
kRegShiftHDMIInputRange
@ kRegShiftHDMIInputRange
Definition: ntv2publicinterface.h:2732
NTV2HDMIOutputStatus
Reports HDMI output status information.
Definition: ntv2publicinterface.h:7145
kVRegHDMIOutHDRBluePrimary3
@ kVRegHDMIOutHDRBluePrimary3
Definition: ntv2virtualregisters.h:662
kVRegHDMIOutHDRControl3
@ kVRegHDMIOutHDRControl3
Definition: ntv2virtualregisters.h:667
NTV2_HDMIAudio8Channels
@ NTV2_HDMIAudio8Channels
8 audio channels
Definition: ntv2enums.h:3648
kVRegHDMIInDrmMasteringLuminence1
@ kVRegHDMIInDrmMasteringLuminence1
Definition: ntv2virtualregisters.h:615
NTV2FrameRate
NTV2FrameRate
Identifies a particular video frame rate.
Definition: ntv2enums.h:406
kVRegHDMIOutControl1
@ kVRegHDMIOutControl1
Definition: ntv2virtualregisters.h:633
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::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
kVRegHDMIOutControl4
@ kVRegHDMIOutControl4
Definition: ntv2virtualregisters.h:669
HDRRegValues::maxFrameAverageLightLevel
uint16_t maxFrameAverageLightLevel
Definition: ntv2publicinterface.h:10211
kRegMaskHDMIInfoRange
@ kRegMaskHDMIInfoRange
Definition: ntv2publicinterface.h:1649
kRegShiftHDMIHDRWhitePointX
@ kRegShiftHDMIHDRWhitePointX
Definition: ntv2publicinterface.h:3272
kRegMaskHDMIHDRNonContantLuminance
@ kRegMaskHDMIHDRNonContantLuminance
Definition: ntv2publicinterface.h:2217
kVRegHDMIInDrmGreenPrimary1
@ kVRegHDMIInDrmGreenPrimary1
Definition: ntv2virtualregisters.h:611
NTV2_IS_VALID_HDR_MASTERING_LUMINENCE
#define NTV2_IS_VALID_HDR_MASTERING_LUMINENCE(__val__)
Definition: ntv2publicinterface.h:10327
CNTV2Card::GetHDMIInColorimetry
virtual bool GetHDMIInColorimetry(NTV2HDMIColorimetry &outColorimetry, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's current colorimetry.
Definition: ntv2hdmi.cpp:157
kVRegHdrTransferCh1
@ kVRegHdrTransferCh1
Definition: ntv2virtualregisters.h:537
kVRegHDMIInDrmGreenPrimary2
@ kVRegHDMIInDrmGreenPrimary2
Definition: ntv2virtualregisters.h:619
HDRRegValues::minMasteringLuminance
uint16_t minMasteringLuminance
Definition: ntv2publicinterface.h:10209
kLHIRegMaskHDMIOutColorSpace
@ kLHIRegMaskHDMIOutColorSpace
Definition: ntv2publicinterface.h:1597
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....
Definition: ntv2hdmi.cpp:946
CNTV2Card::GetHDMIHDREnabled
virtual bool GetHDMIHDREnabled(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1050
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:433
kRegMaskHDMISwapOutputAudCh34
@ kRegMaskHDMISwapOutputAudCh34
Definition: ntv2publicinterface.h:1637
kRegShiftHDMIInfoRange
@ kRegShiftHDMIInfoRange
Definition: ntv2publicinterface.h:2734
kRegHDMIOutControl
@ kRegHDMIOutControl
Definition: ntv2publicinterface.h:258
CNTV2Card::GetHDMIOutColorSpace
virtual bool GetHDMIOutColorSpace(NTV2HDMIColorSpace &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:450
kRegMaskHDMIHDRDolbyVisionEnable
@ kRegMaskHDMIHDRDolbyVisionEnable
Definition: ntv2publicinterface.h:2218
isEnabled
static bool isEnabled(CNTV2Card &device, const NTV2Channel inChannel)
Definition: ntv2supportlogger.cpp:143
CNTV2Card::SetHDMIOutLevelBMode
virtual bool SetHDMIOutLevelBMode(const bool inEnable)
Enables or disables level-B mode on the device's HDMI rasterizer.
Definition: ntv2hdmi.cpp:664
kRegMaskHDMIOutVideoStd
@ kRegMaskHDMIOutVideoStd
Definition: ntv2publicinterface.h:1593
kRegMaskTsiIO
@ kRegMaskTsiIO
Definition: ntv2publicinterface.h:2112
kRegShiftRasterMode
@ kRegShiftRasterMode
Definition: ntv2publicinterface.h:3173
kRegShiftHDMIOut3DPresent
@ kRegShiftHDMIOut3DPresent
Definition: ntv2publicinterface.h:2677
kLHIRegShiftHDMIInputBitDepth
@ kLHIRegShiftHDMIInputBitDepth
Definition: ntv2publicinterface.h:2704
kRegHDMIHDRMasteringLuminence
@ kRegHDMIHDRMasteringLuminence
Definition: ntv2publicinterface.h:487
kRegShiftHDMISwapInputAudCh34
@ kRegShiftHDMISwapInputAudCh34
Definition: ntv2publicinterface.h:2721
gHDMIChannelToOutHDRLightLevelVRegNum
static const ULWord gHDMIChannelToOutHDRLightLevelVRegNum[]
Definition: ntv2hdmi.cpp:42
kRegMaskHDMIOut12Bit
@ kRegMaskHDMIOut12Bit
Definition: ntv2publicinterface.h:1645
gHDMIChannelToOutHDRGreenPrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRGreenPrimaryVRegNum[]
Definition: ntv2hdmi.cpp:32
kVRegHDMIOutHDRWhitePoint2
@ kVRegHDMIOutHDRWhitePoint2
Definition: ntv2virtualregisters.h:652
kLHIRegMaskHDMIOutDVI
@ kLHIRegMaskHDMIOutDVI
Definition: ntv2publicinterface.h:1611
kRegShiftHDMIInColorDepth
@ kRegShiftHDMIInColorDepth
Definition: ntv2publicinterface.h:2724
kRegMaskHDRStaticMetadataDescriptorID
@ kRegMaskHDRStaticMetadataDescriptorID
Definition: ntv2publicinterface.h:2221
CNTV2Card::SetHDMIOutDisable
virtual bool SetHDMIOutDisable(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:603
HDRRegValues::whitePointY
uint16_t whitePointY
Definition: ntv2publicinterface.h:10207
CNTV2Card::GetHDMIOutLevelBMode
virtual bool GetHDMIOutLevelBMode(bool &outIsEnabled)
Definition: ntv2hdmi.cpp:671
CNTV2Card::SetHDMIHDRStaticMetadataDescriptorID
virtual bool SetHDMIHDRStaticMetadataDescriptorID(const uint8_t inSMDId, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1014
NTV2Standard
NTV2Standard
Identifies a particular video standard.
Definition: ntv2enums.h:159
CNTV2Card::SetHDMIOut3DPresent
virtual bool SetHDMIOut3DPresent(const bool inIs3DPresent)
Definition: ntv2hdmi.cpp:314
kDeviceCanDoHDMIHDROut
@ kDeviceCanDoHDMIHDROut
True if device supports HDMI HDR output.
Definition: ntv2devicefeatures.h:115
HDRRegValues::greenPrimaryX
uint16_t greenPrimaryX
Definition: ntv2publicinterface.h:10200
ULWord
uint32_t ULWord
Definition: ajatypes.h:256
kRegMaskHDMIHDRBluePrimaryX
@ kRegMaskHDMIHDRBluePrimaryX
Definition: ntv2publicinterface.h:2206
NTV2_IS_VALID_HDMI_SAMPLE_STRUCT
#define NTV2_IS_VALID_HDMI_SAMPLE_STRUCT(_x_)
Definition: ntv2enums.h:4176
kLHIRegMaskHDMIOutBitDepth
@ kLHIRegMaskHDMIOutBitDepth
Definition: ntv2publicinterface.h:1600
kVRegHDMIOutHDRRedPrimary3
@ kVRegHDMIOutHDRRedPrimary3
Definition: ntv2virtualregisters.h:663
kVRegHDMIInputStatus2
@ kVRegHDMIInputStatus2
Definition: ntv2virtualregisters.h:646
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
gHDMIChannelToOutHDRMasterLuminanceVRegNum
static const ULWord gHDMIChannelToOutHDRMasterLuminanceVRegNum[]
Definition: ntv2hdmi.cpp:40
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
kLHIRegMaskHDMIOutputEDID10Bit
@ kLHIRegMaskHDMIOutputEDID10Bit
Definition: ntv2publicinterface.h:1621
kVRegHDMIInAviInfo1
@ kVRegHDMIInAviInfo1
Definition: ntv2virtualregisters.h:609
gHDMIChannelToOutHDRRedPrimaryVRegNum
static const ULWord gHDMIChannelToOutHDRRedPrimaryVRegNum[]
Definition: ntv2hdmi.cpp:34
CNTV2Card::SetHDMIOutForceConfig
virtual bool SetHDMIOutForceConfig(const bool inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:587
kRegMaskHDMIHDRMinMasteringLuminance
@ kRegMaskHDMIHDRMinMasteringLuminance
Definition: ntv2publicinterface.h:2213
kVRegHDMIInDrmWhitePoint2
@ kVRegHDMIInDrmWhitePoint2
Definition: ntv2virtualregisters.h:622
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:924
NTV2_IS_VALID_HDMI_RANGE
#define NTV2_IS_VALID_HDMI_RANGE(__x__)
Definition: ntv2enums.h:3621
NTV2HDMIProtocol
NTV2HDMIProtocol
Indicates or specifies the HDMI protocol.
Definition: ntv2enums.h:3599
HDRRegValues::zero
HDRRegValues & zero(void)
Definition: ntv2publicinterface.h:10216
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
kRegHDMIInputStatus2
@ kRegHDMIInputStatus2
Definition: ntv2publicinterface.h:1038
CNTV2Card::GetHDMIOutInputControlRegNum
virtual bool GetHDMIOutInputControlRegNum(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1240
NTV2_IS_VALID_HDMI_PROTOCOL
#define NTV2_IS_VALID_HDMI_PROTOCOL(__x__)
Definition: ntv2enums.h:3607
ntv2card.h
Declares the CNTV2Card class.
kVRegHDMIOutHDRMasterLuminance1
@ kVRegHDMIOutHDRMasterLuminance1
Definition: ntv2virtualregisters.h:641
kRegMaskHDMIHDRWhitePointX
@ kRegMaskHDMIHDRWhitePointX
Definition: ntv2publicinterface.h:2210
kRegMaskHDMIHDRRedPrimaryY
@ kRegMaskHDMIHDRRedPrimaryY
Definition: ntv2publicinterface.h:2209
kDeviceGetHDMIVersion
@ kDeviceGetHDMIVersion
The version number of the HDMI chipset on the device.
Definition: ntv2devicefeatures.h:177
kRegMaskHDMISampling
@ kRegMaskHDMISampling
Definition: ntv2publicinterface.h:1603
kRegMaskHDMIHDRGreenPrimaryY
@ kRegMaskHDMIHDRGreenPrimaryY
Definition: ntv2publicinterface.h:2205
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:1188
kRegShiftRasterDecimate
@ kRegShiftRasterDecimate
Definition: ntv2publicinterface.h:3176
kVRegHDMIOutHDRLightLevel1
@ kVRegHDMIOutHDRLightLevel1
Definition: ntv2virtualregisters.h:642
kRegHDMIControl1
@ kRegHDMIControl1
Definition: ntv2publicinterface.h:1036
NTV2_HDMIColorSpaceYCbCr
@ NTV2_HDMIColorSpaceYCbCr
YCbCr color space.
Definition: ntv2enums.h:3587
kVRegHDMIOutHDRWhitePoint1
@ kVRegHDMIOutHDRWhitePoint1
Definition: ntv2virtualregisters.h:640
UWord
uint16_t UWord
Definition: ajatypes.h:254
kVRegHDMIOutHDRRedPrimary4
@ kVRegHDMIOutHDRRedPrimary4
Definition: ntv2virtualregisters.h:675
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_HDMI8Bit
@ NTV2_HDMI8Bit
8 bit
Definition: ntv2enums.h:3672
kVRegHDMIInputStatus1
@ kVRegHDMIInputStatus1
Definition: ntv2virtualregisters.h:634
kRegHDMIInputControl
@ kRegHDMIInputControl
Definition: ntv2publicinterface.h:260
kVRegMaskHDMIInColorimetry
@ kVRegMaskHDMIInColorimetry
Definition: ntv2virtualregisters.h:749
kRegMaskHDMIOutRange
@ kRegMaskHDMIOutRange
Definition: ntv2publicinterface.h:1609
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:728
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:718
kRegShiftHDMIHDRMaxMasteringLuminance
@ kRegShiftHDMIHDRMaxMasteringLuminance
Definition: ntv2publicinterface.h:3274
kVRegMaskHDMIInEOTF
@ kVRegMaskHDMIInEOTF
Definition: ntv2virtualregisters.h:752
HDRRegValues::redPrimaryX
uint16_t redPrimaryX
Definition: ntv2publicinterface.h:10204
kLHIRegShiftHDMIOutDVI
@ kLHIRegShiftHDMIOutDVI
Definition: ntv2publicinterface.h:2697
CNTV2Card::GetHDMIOutStatusReg
virtual bool GetHDMIOutStatusReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1251
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_IS_VALID_HDR_PRIMARY
#define NTV2_IS_VALID_HDR_PRIMARY(__val__)
Definition: ntv2publicinterface.h:10326
kRegMaskHDMIHDRMaxContentLightLevel
@ kRegMaskHDMIHDRMaxContentLightLevel
Definition: ntv2publicinterface.h:2214
CNTV2Card::SetHDMIHDRBT2020
virtual bool SetHDMIHDRBT2020(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1137
kVRegHdrBlueXCh1
@ kVRegHdrBlueXCh1
Definition: ntv2virtualregisters.h:541
CNTV2Card::GetHDMIOutControlReg
virtual bool GetHDMIOutControlReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1218
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:815
kRegShiftHDMIOut12Bit
@ kRegShiftHDMIOut12Bit
Definition: ntv2publicinterface.h:2730
kLHIRegMaskHDMIOutputEDIDRGB
@ kLHIRegMaskHDMIOutputEDIDRGB
Definition: ntv2publicinterface.h:1620
kVRegHDMIOutHDRRedPrimary2
@ kVRegHDMIOutHDRRedPrimary2
Definition: ntv2virtualregisters.h:651
kRegShiftHDMIHDRBluePrimaryY
@ kRegShiftHDMIHDRBluePrimaryY
Definition: ntv2publicinterface.h:3269
kRegMaskHDMISampleRateConverterEnable
@ kRegMaskHDMISampleRateConverterEnable
Definition: ntv2publicinterface.h:1635
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
HDRRegValues::maxMasteringLuminance
uint16_t maxMasteringLuminance
Definition: ntv2publicinterface.h:10208
kVRegHDMIOutHDRMasterLuminance4
@ kVRegHDMIOutHDRMasterLuminance4
Definition: ntv2virtualregisters.h:677
CNTV2Card::SetHDMIInColorSpace
virtual bool SetHDMIInColorSpace(const NTV2HDMIColorSpace inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input's color space.
Definition: ntv2hdmi.cpp:194
NTV2_INVALID_HDMI_PROTOCOL
@ NTV2_INVALID_HDMI_PROTOCOL
Definition: ntv2enums.h:3604
kRegMaskHDMIOut3DMode
@ kRegMaskHDMIOut3DMode
Definition: ntv2publicinterface.h:1590
kRegMaskHDMIInputRange
@ kRegMaskHDMIInputRange
Definition: ntv2publicinterface.h:1647
CNTV2Card::GetHDMIV2Mode
virtual bool GetHDMIV2Mode(NTV2HDMIV2Mode &outMode)
Answers with the current HDMI V2 mode of the device.
Definition: ntv2hdmi.cpp:685
kVRegHDMIInputControl4
@ kVRegHDMIInputControl4
Definition: ntv2virtualregisters.h:671
kVRegHDMIOutHDRBluePrimary2
@ kVRegHDMIOutHDRBluePrimary2
Definition: ntv2virtualregisters.h:650
CNTV2Card::GetHDRData
virtual bool GetHDRData(HDRFloatValues &outFloatValues, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1113
kRegHDMIInputStatus
@ kRegHDMIInputStatus
Definition: ntv2publicinterface.h:259
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:794
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:892
kRegHDMIControl4
@ kRegHDMIControl4
Definition: ntv2publicinterface.h:1045
CNTV2Card::GetHDMIOut3DPresent
virtual bool GetHDMIOut3DPresent(bool &outIs3DPresent)
Definition: ntv2hdmi.cpp:320
kVRegHDMIInDrmLightLevel1
@ kVRegHDMIInDrmLightLevel1
Definition: ntv2virtualregisters.h:616
kDeviceGetNumHDMIVideoInputs
@ kDeviceGetNumHDMIVideoInputs
The number of HDMI video inputs on the device.
Definition: ntv2devicefeatures.h:203
kVRegMaskHDMIInDolbyVision
@ kVRegMaskHDMIInDolbyVision
Definition: ntv2virtualregisters.h:750
NTV2_INVALID_HDMIBitDepth
@ NTV2_INVALID_HDMIBitDepth
Definition: ntv2enums.h:3676
NTV2HDMIColorimetry
NTV2HDMIColorimetry
Indicates or specifies the HDMI colorimetry.
Definition: ntv2enums.h:3627
CNTV2Card::GetHDMIHDRConstantLuminance
virtual bool GetHDMIHDRConstantLuminance(const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:980
CNTV2Card::SetHDMIHDRElectroOpticalTransferFunction
virtual bool SetHDMIHDRElectroOpticalTransferFunction(const uint8_t inEOTFByte, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:992
kVRegHdrRedXCh1
@ kVRegHdrRedXCh1
Definition: ntv2virtualregisters.h:543
CNTV2Card::SetHDRData
virtual bool SetHDRData(const HDRFloatValues &inFloatValues, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:1089
kVRegShiftHDMIInDolbyVision
@ kVRegShiftHDMIInDolbyVision
Definition: ntv2virtualregisters.h:772
kRegShiftHDMIVOBD
@ kRegShiftHDMIVOBD
Definition: ntv2publicinterface.h:2692
NTV2HDMIV2Mode
NTV2HDMIV2Mode
Definition: ntv2enums.h:3978
kVRegHdrMaxCLLCh1
@ kVRegHdrMaxCLLCh1
Definition: ntv2virtualregisters.h:549
HDRRegValues::greenPrimaryY
uint16_t greenPrimaryY
Definition: ntv2publicinterface.h:10201
kRegMaskInputStatusLock
@ kRegMaskInputStatusLock
Definition: ntv2publicinterface.h:1615
kVRegHDMIOutHDRLightLevel3
@ kVRegHDMIOutHDRLightLevel3
Definition: ntv2virtualregisters.h:666
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....
Definition: ntv2hdmi.cpp:848
NTV2_LHIHDMIColorSpaceYCbCr
@ NTV2_LHIHDMIColorSpaceYCbCr
Definition: ntv2enums.h:3658
NTV2_IS_VALID_HDR_LIGHT_LEVEL
#define NTV2_IS_VALID_HDR_LIGHT_LEVEL(__val__)
Definition: ntv2publicinterface.h:10328
kRegMaskRasterDecimate
@ kRegMaskRasterDecimate
Definition: ntv2publicinterface.h:2114
gHDMIChannelToOutHDRWhitePointVRegNum
static const ULWord gHDMIChannelToOutHDRWhitePointVRegNum[]
Definition: ntv2hdmi.cpp:38
CNTV2Card::EnableHDMIHDR
virtual bool EnableHDMIHDR(const bool inEnableHDMIHDR, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables HDMI HDR.
Definition: ntv2hdmi.cpp:1036
gHDMIChannelToInputStatusRegNum
static const ULWord gHDMIChannelToInputStatusRegNum[]
Definition: ntv2hdmi.cpp:20
kVRegHdrMaxFALLCh1
@ kVRegHdrMaxFALLCh1
Definition: ntv2virtualregisters.h:550
kRegHDMIOut3DControl
@ kRegHDMIOut3DControl
Definition: ntv2publicinterface.h:257
kLHIRegShiftHDMIOutputEDIDRGB
@ kLHIRegShiftHDMIOutputEDIDRGB
Definition: ntv2publicinterface.h:2706
kDeviceGetNumHDMIVideoOutputs
@ kDeviceGetNumHDMIVideoOutputs
The number of HDMI video outputs on the device.
Definition: ntv2devicefeatures.h:204
kRegMaskHDMISwapInputAudCh34
@ kRegMaskHDMISwapInputAudCh34
Definition: ntv2publicinterface.h:1636
kRegHDMIHDRRedPrimary
@ kRegHDMIHDRRedPrimary
Definition: ntv2publicinterface.h:485
CNTV2Card::GetHDMIOutHDRControlReg
virtual bool GetHDMIOutHDRControlReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1328
kLHIRegMaskHDMIInputColorSpace
@ kLHIRegMaskHDMIInputColorSpace
Definition: ntv2publicinterface.h:1617
CNTV2Card::GetHDMIInVideoRange
virtual bool GetHDMIInVideoRange(NTV2HDMIRange &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's video black/white range.
Definition: ntv2hdmi.cpp:79
kLHIRegShiftHDMIOutputEDID10Bit
@ kLHIRegShiftHDMIOutputEDID10Bit
Definition: ntv2publicinterface.h:2707
kRegShiftHDMIHDRRedPrimaryY
@ kRegShiftHDMIHDRRedPrimaryY
Definition: ntv2publicinterface.h:3271
kRegShiftHDMIOut3DMode
@ kRegShiftHDMIOut3DMode
Definition: ntv2publicinterface.h:2678
CNTV2Card::SetHDMIOutColorSpace
virtual bool SetHDMIOutColorSpace(const NTV2HDMIColorSpace inNewValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:428
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
kVRegHDMIInputStatus3
@ kVRegHDMIInputStatus3
Definition: ntv2virtualregisters.h:658
kVRegHDMIInDrmMasteringLuminence2
@ kVRegHDMIInDrmMasteringLuminence2
Definition: ntv2virtualregisters.h:623
kRegShiftHDMIHDREnable
@ kRegShiftHDMIHDREnable
Definition: ntv2publicinterface.h:3281
kVRegHdrLuminanceCh1
@ kVRegHdrLuminanceCh1
Definition: ntv2virtualregisters.h:538
CNTV2Card::GetHDMIOutStatus
virtual bool GetHDMIOutStatus(NTV2HDMIOutputStatus &outStatus, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Answers with the current HDMI output status.
Definition: ntv2hdmi.cpp:692
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:706
kLHIRegMaskHDMIInputBitDepth
@ kLHIRegMaskHDMIInputBitDepth
Definition: ntv2publicinterface.h:1618
kVRegHdrRedYCh1
@ kVRegHdrRedYCh1
Definition: ntv2virtualregisters.h:544
CNTV2Card::GetHDMIOutHDRRedPrimaryReg
virtual bool GetHDMIOutHDRRedPrimaryReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1284
kLHIRegShiftHDMIInputColorSpace
@ kLHIRegShiftHDMIInputColorSpace
Definition: ntv2publicinterface.h:2703
std
Definition: json.hpp:5362
kRegMaskHDMIColorSpace
@ kRegMaskHDMIColorSpace
Definition: ntv2publicinterface.h:1652
kVRegHDMIOutHDRMasterLuminance3
@ kVRegHDMIOutHDRMasterLuminance3
Definition: ntv2virtualregisters.h:665
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::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
kVRegHDMIInputControl3
@ kVRegHDMIInputControl3
Definition: ntv2virtualregisters.h:659
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:784
kVRegMaskHDMIInMetadataID
@ kVRegMaskHDMIInMetadataID
Definition: ntv2virtualregisters.h:753
CNTV2Card::SetHDMIOutTsiIO
virtual bool SetHDMIOutTsiIO(const bool inTsiEnable)
Enables or disables two sample interleave I/O mode on the device's HDMI rasterizer.
Definition: ntv2hdmi.cpp:650
kVRegHDMIInDrmWhitePoint1
@ kVRegHDMIInDrmWhitePoint1
Definition: ntv2virtualregisters.h:614
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....
Definition: ntv2hdmi.cpp:936
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
kVRegHDMIOutHDRControl2
@ kVRegHDMIOutHDRControl2
Definition: ntv2virtualregisters.h:655
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....
Definition: ntv2hdmi.cpp:805
kVRegShiftHDMIInMetadataID
@ kVRegShiftHDMIInMetadataID
Definition: ntv2virtualregisters.h:775
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:958
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:762
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:858
kRegMaskHDMIHDRWhitePointY
@ kRegMaskHDMIHDRWhitePointY
Definition: ntv2publicinterface.h:2211
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:1198
kVRegHDMIInputStatus4
@ kVRegHDMIInputStatus4
Definition: ntv2virtualregisters.h:670
gKonaHDMICtrlRegs
static const ULWord gKonaHDMICtrlRegs[]
Definition: ntv2hdmi.cpp:292
kVRegHDMIOutHDRWhitePoint4
@ kVRegHDMIOutHDRWhitePoint4
Definition: ntv2virtualregisters.h:676
kRegShiftHDMIOutCropEnable
@ kRegShiftHDMIOutCropEnable
Definition: ntv2publicinterface.h:2728
true
#define true
Definition: ntv2devicefeatures.h:26
kRegMaskHDMIOutPrefer420
@ kRegMaskHDMIOutPrefer420
Definition: ntv2publicinterface.h:1638
kVRegHdrWhiteYCh1
@ kVRegHdrWhiteYCh1
Definition: ntv2virtualregisters.h:546
kRegShiftHDMISwapOutputAudCh34
@ kRegShiftHDMISwapOutputAudCh34
Definition: ntv2publicinterface.h:2722
kRegMaskHDMIOutCropEnable
@ kRegMaskHDMIOutCropEnable
Definition: ntv2publicinterface.h:1643
NTV2_IS_VALID_NTV2FrameRate
#define NTV2_IS_VALID_NTV2FrameRate(__r__)
Definition: ntv2enums.h:438
kRegShiftHDMIHDRMinMasteringLuminance
@ kRegShiftHDMIHDRMinMasteringLuminance
Definition: ntv2publicinterface.h:3275
kLHIRegMaskHDMIInput2ChAudio
@ kLHIRegMaskHDMIInput2ChAudio
Definition: ntv2publicinterface.h:1622
kRegMaskHDMIHDRMaxFrameAverageLightLevel
@ kRegMaskHDMIHDRMaxFrameAverageLightLevel
Definition: ntv2publicinterface.h:2215
kLHIRegShiftHDMIOutFPS
@ kLHIRegShiftHDMIOutFPS
Definition: ntv2publicinterface.h:2687
kVRegHDMIOutHDRControl1
@ kVRegHDMIOutHDRControl1
Definition: ntv2virtualregisters.h:643
kVRegHdrGreenXCh1
@ kVRegHdrGreenXCh1
Definition: ntv2virtualregisters.h:539
kRegShiftHDMIOutPrefer420
@ kRegShiftHDMIOutPrefer420
Definition: ntv2publicinterface.h:2723
HDRRegValues::bluePrimaryY
uint16_t bluePrimaryY
Definition: ntv2publicinterface.h:10203
kRegMaskHDMIOutV2VideoStd
@ kRegMaskHDMIOutV2VideoStd
Definition: ntv2publicinterface.h:1594
CNTV2Card::SetHDMIV2Mode
virtual bool SetHDMIV2Mode(const NTV2HDMIV2Mode inMode)
Sets HDMI V2 mode for the device.
Definition: ntv2hdmi.cpp:678
kVRegHDMIInDrmInfo2
@ kVRegHDMIInDrmInfo2
Definition: ntv2virtualregisters.h:618
NTV2_IS_VALID_HDMI_BITDEPTH
#define NTV2_IS_VALID_HDMI_BITDEPTH(__x__)
Definition: ntv2enums.h:3679
kVRegHDMIInDrmRedPrimary2
@ kVRegHDMIInDrmRedPrimary2
Definition: ntv2virtualregisters.h:621
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
NTV2HDMIOutputStatus::SetFromRegValue
bool SetFromRegValue(const ULWord inData)
Sets my fields from the given status register value.
Definition: ntv2publicinterface.cpp:164
kVRegHDMIOutHDRGreenPrimary1
@ kVRegHDMIOutHDRGreenPrimary1
Definition: ntv2virtualregisters.h:637
CNTV2Card::SetHDMIOutDecimateMode
virtual bool SetHDMIOutDecimateMode(const bool inEnable)
Enables or disables decimate mode on the device's HDMI rasterizer, which halves the output frame rate...
Definition: ntv2hdmi.cpp:636
NTV2_HDMIColorSpaceRGB
@ NTV2_HDMIColorSpaceRGB
RGB color space.
Definition: ntv2enums.h:3586
kRegShiftHDMIHDRMaxFrameAverageLightLevel
@ kRegShiftHDMIHDRMaxFrameAverageLightLevel
Definition: ntv2publicinterface.h:3277
kRegShiftHDMIHDRDolbyVisionEnable
@ kRegShiftHDMIHDRDolbyVisionEnable
Definition: ntv2publicinterface.h:3280
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
kVRegHdrWhiteXCh1
@ kVRegHdrWhiteXCh1
Definition: ntv2virtualregisters.h:545
NTV2_HDMI10Bit
@ NTV2_HDMI10Bit
10 bit
Definition: ntv2enums.h:3673
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
kRegShiftHDMIOutDisable
@ kRegShiftHDMIOutDisable
Definition: ntv2publicinterface.h:2698
NTV2HDMISampleStructure
NTV2HDMISampleStructure
Definition: ntv2enums.h:4165
kRegShiftElectroOpticalTransferFunction
@ kRegShiftElectroOpticalTransferFunction
Definition: ntv2publicinterface.h:3282
kRegShiftHDMIHDRNonContantLuminance
@ kRegShiftHDMIHDRNonContantLuminance
Definition: ntv2publicinterface.h:3279
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....
Definition: ntv2hdmi.cpp:870
kRegHDMIInputStatus1
@ kRegHDMIInputStatus1
Definition: ntv2publicinterface.h:1035
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
kRegShiftHDMIHDRRedPrimaryX
@ kRegShiftHDMIHDRRedPrimaryX
Definition: ntv2publicinterface.h:3270
BIT
#define BIT(_x_)
Definition: ajatypes.h:565
kRegMaskHDMIInColorDepth
@ kRegMaskHDMIInColorDepth
Definition: ntv2publicinterface.h:1639
CNTV2Card::GetHDMIOutForceConfig
virtual bool GetHDMIOutForceConfig(bool &outValue, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Definition: ntv2hdmi.cpp:595
HDRRegValues::setBT2020
HDRRegValues & setBT2020(void)
Definition: ntv2publicinterface.h:10224
kRegShiftHDMIHDRBluePrimaryX
@ kRegShiftHDMIHDRBluePrimaryX
Definition: ntv2publicinterface.h:3268
HDRRegValues
defined(NTV2_DEPRECATE_17_6)
Definition: ntv2publicinterface.h:10198
HDRFloatValues::toRegValues
bool toRegValues(HDRRegValues &outVals) const
Definition: ntv2publicinterface.h:10288
NTV2HDMIOut3DMode
NTV2HDMIOut3DMode
This specifies the HDMI Out Stereo 3D Mode.
Definition: ntv2enums.h:3571
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:750
kRegHDMIInputStatus4
@ kRegHDMIInputStatus4
Definition: ntv2publicinterface.h:1044
kVRegHDMIOutHDRControl4
@ kVRegHDMIOutHDRControl4
Definition: ntv2virtualregisters.h:679
kLHIRegShiftHDMIOutBitDepth
@ kLHIRegShiftHDMIOutBitDepth
Definition: ntv2publicinterface.h:2689
CNTV2Card::SetHDMIV2TxBypass
virtual bool SetHDMIV2TxBypass(const bool inBypass)
Definition: ntv2hdmi.cpp:362
kVRegHdrMasterLumMinCh1
@ kVRegHdrMasterLumMinCh1
Definition: ntv2virtualregisters.h:548
CNTV2Card::GetHDMIOutHDRLightLevelReg
virtual bool GetHDMIOutHDRLightLevelReg(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1317
CNTV2Card::GetHDMIOutInputStatusRegNum
virtual bool GetHDMIOutInputStatusRegNum(ULWord &outRegNum, const NTV2Channel inWhichHDMIOut)
Definition: ntv2hdmi.cpp:1229
kLHIRegShiftHDMIOutColorSpace
@ kLHIRegShiftHDMIOutColorSpace
Definition: ntv2publicinterface.h:2686
kRegMaskHDMIV2TxBypass
@ kRegMaskHDMIV2TxBypass
Definition: ntv2publicinterface.h:1596
CNTV2Card::EnableHDMIHDRDolbyVision
virtual bool EnableHDMIHDRDolbyVision(const bool inEnable, const NTV2Channel inWhichHDMIOut=NTV2_CHANNEL1)
Enables or disables HDMI HDR Dolby Vision.
Definition: ntv2hdmi.cpp:1063
kVRegShiftHDMIInEOTF
@ kVRegShiftHDMIInEOTF
Definition: ntv2virtualregisters.h:774
kVRegMaskHDMIInPresent
@ kVRegMaskHDMIInPresent
Definition: ntv2virtualregisters.h:751
kRegShiftTsiIO
@ kRegShiftTsiIO
Definition: ntv2publicinterface.h:3174
kVRegHdrGreenYCh1
@ kVRegHdrGreenYCh1
Definition: ntv2virtualregisters.h:540
CNTV2Card::SetHDMIInputRange
virtual bool SetHDMIInputRange(const NTV2HDMIRange inNewValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Sets the given HDMI input's input range.
Definition: ntv2hdmi.cpp:176
HDRRegValues::staticMetadataDescriptorID
uint8_t staticMetadataDescriptorID
Definition: ntv2publicinterface.h:10213
kVRegHDMIOutStatus4
@ kVRegHDMIOutStatus4
Definition: ntv2virtualregisters.h:672
CNTV2Card::SetHDMIOut3DMode
virtual bool SetHDMIOut3DMode(const NTV2HDMIOut3DMode inValue)
Definition: ntv2hdmi.cpp:326
HDRRegValues::electroOpticalTransferFunction
uint8_t electroOpticalTransferFunction
Definition: ntv2publicinterface.h:10212
kVRegHDMIOutHDRLightLevel2
@ kVRegHDMIOutHDRLightLevel2
Definition: ntv2virtualregisters.h:654
kRegHDMIHDRLightLevel
@ kRegHDMIHDRLightLevel
Definition: ntv2publicinterface.h:488
kVRegHdrColorimetryCh1
@ kVRegHdrColorimetryCh1
Definition: ntv2virtualregisters.h:536
NTV2_HDMI12Bit
@ NTV2_HDMI12Bit
12 bit
Definition: ntv2enums.h:3674
CNTV2Card::GetHDMIInBitDepth
virtual bool GetHDMIInBitDepth(NTV2HDMIBitDepth &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's current bit depth setting.
Definition: ntv2hdmi.cpp:225
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:772
CNTV2Card::GetHDMIInProtocol
virtual bool GetHDMIInProtocol(NTV2HDMIProtocol &outValue, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's protocol.
Definition: ntv2hdmi.cpp:238
kRegHDMIInputStatus3
@ kRegHDMIInputStatus3
Definition: ntv2publicinterface.h:1041
gHDMIChannelToOutHDRControlVRegNum
static const ULWord gHDMIChannelToOutHDRControlVRegNum[]
Definition: ntv2hdmi.cpp:44
kVRegHDMIOutHDRBluePrimary1
@ kVRegHDMIOutHDRBluePrimary1
Definition: ntv2virtualregisters.h:638
CNTV2Card::GetHDMIInDolbyVision
virtual bool GetHDMIInDolbyVision(bool &outIsDetected, const NTV2Channel inHDMIInput=NTV2_CHANNEL1)
Answers with the given HDMI input's Dolby Vision flag value.
Definition: ntv2hdmi.cpp:166
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:914