/// <summary>
/// Make a Crestron RMC and put it in here
/// </summary>
public DmRmc150SController(string key, string name, DmRmc150S rmc)
: base(key, name, rmc)
{
_rmc = rmc;
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this);
EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut
};
_rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
// Set Ports for CEC
HdmiOut.Port = _rmc.HdmiOutput;
}
public DmRmc4kZScalerCController(string key, string name, DmRmc4kzScalerC rmc)
: base(key, name, rmc)
{
_rmc = rmc;
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HdmiIn = new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, 0, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this);
EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn, HdmiIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut
};
_rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
_rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
// Set Ports for CEC
HdmiOut.Port = _rmc.HdmiOutput;
AudioVideoSourceNumericFeedback = new IntFeedback(() => (ushort)(_rmc.SelectedSourceFeedback));
}
public IRSetTopBoxBase(string key, string name, IrOutputPortController portCont,
SetTopBoxPropertiesConfig props)
: base(key, name)
{
IrPort = portCont;
DeviceManager.AddDevice(portCont);
HasPresets = props.HasPresets;
HasDvr = props.HasDvr;
HasDpad = props.HasDpad;
HasNumeric = props.HasNumeric;
HasKeypadAccessoryButton1 = true;
KeypadAccessoryButton1Command = "Dash";
KeypadAccessoryButton1Label = "-";
HasKeypadAccessoryButton2 = true;
KeypadAccessoryButton2Command = "NumericEnter";
KeypadAccessoryButton2Label = "Enter";
AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this);
AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio,
eRoutingPortConnectionType.DigitalAudio, null, this);
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
AnyVideoOut, AnyAudioOut
};
}
protected CameraBase(string key, string name) :
base(key, name)
{
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
ControlMode = eCameraControlMode.Manual;
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="chassis"></param>
public DmpsRoutingController(string key, string name, ISystemControl systemControl)
: base(key, name)
{
Dmps = Global.ControlSystem;
SystemControl = systemControl;
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
VolumeControls = new Dictionary <uint, DmCardAudioOutputController>();
TxDictionary = new Dictionary <uint, string>();
RxDictionary = new Dictionary <uint, string>();
VideoOutputFeedbacks = new Dictionary <uint, IntFeedback>();
AudioOutputFeedbacks = new Dictionary <uint, IntFeedback>();
VideoInputSyncFeedbacks = new Dictionary <uint, BoolFeedback>();
InputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputVideoRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputAudioRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
InputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
OutputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
Debug.Console(1, this, "{0} Switcher Inputs Present.", Dmps.SwitcherInputs.Count);
Debug.Console(1, this, "{0} Switcher Outputs Present.", Dmps.SwitcherOutputs.Count);
SetupOutputCards();
SetupInputCards();
}
public GenericSource(string key, string name)
: base(key, name)
{
AnyOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this);
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
AnyOut
};
}
public Amplifier(string key, string name)
: base(key, name)
{
AudioIn = new RoutingInputPort(RoutingPortNames.AnyAudioIn, eRoutingSignalType.Audio,
eRoutingPortConnectionType.None, null, this);
InputPorts = new RoutingPortCollection <RoutingInputPort> {
AudioIn
};
}
public Laptop(string key, string name)
: base(key, name)
{
IconName = "Laptop";
HasPowerOnFeedback = new BoolFeedback("HasPowerFeedback",
() => this.GetVideoStatuses() != VideoStatusOutputs.NoStatus);
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.None, 0, this));
}
public Roku2(string key, string name, IrOutputPortController portCont)
: base(key, name)
{
IrPort = portCont;
DeviceManager.AddDevice(portCont);;
HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this);
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut
};
}
public AirMediaController(string key, string name, AmX00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
: base(key, name, device)
{
AirMedia = device;
DeviceConfig = dc;
PropertiesConfig = props;
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.None, new Action(SelectPinPointUxLandingPage), this));
InputPorts.Add(new RoutingInputPort(DmPortName.AirMediaIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Streaming, new Action(SelectAirMedia), this));
InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, new Action(SelectHdmiIn), this));
InputPorts.Add(new RoutingInputPort(DmPortName.AirBoardIn, eRoutingSignalType.Video,
eRoutingPortConnectionType.None, new Action(SelectAirboardIn), this));
if (AirMedia is Am300)
{
InputPorts.Add(new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmCat, new Action(SelectDmIn), this));
}
AirMedia.AirMedia.AirMediaChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(AirMedia_AirMediaChange);
IsInSessionFeedback = new BoolFeedback(new Func <bool>(() => AirMedia.AirMedia.StatusFeedback.UShortValue == 0));
ErrorFeedback = new IntFeedback(new Func <int>(() => AirMedia.AirMedia.ErrorFeedback.UShortValue));
NumberOfUsersConnectedFeedback = new IntFeedback(new Func <int>(() => AirMedia.AirMedia.NumberOfUsersConnectedFeedback.UShortValue));
LoginCodeFeedback = new IntFeedback(new Func <int>(() => AirMedia.AirMedia.LoginCodeFeedback.UShortValue));
ConnectionAddressFeedback = new StringFeedback(new Func <string>(() => AirMedia.AirMedia.ConnectionAddressFeedback.StringValue));
HostnameFeedback = new StringFeedback(new Func <string>(() => AirMedia.AirMedia.HostNameFeedback.StringValue));
// TODO: Figure out if we can actually get the TSID/Serial
SerialNumberFeedback = new StringFeedback(new Func <string>(() => "unknown"));
AirMedia.DisplayControl.DisplayControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(DisplayControl_DisplayControlChange);
VideoOutFeedback = new IntFeedback(new Func <int>(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback)));
AutomaticInputRoutingEnabledFeedback = new BoolFeedback(new Func <bool>(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue));
AirMedia.HdmiIn.StreamChange += new Crestron.SimplSharpPro.DeviceSupport.StreamEventHandler(HdmiIn_StreamChange);
HdmiVideoSyncDetectedFeedback = new BoolFeedback(new Func <bool>(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue));
}
public VideoCodecBase(DeviceConfig config)
: base(config)
{
StandbyIsOnFeedback = new BoolFeedback(StandbyIsOnFeedbackFunc);
PrivacyModeIsOnFeedback = new BoolFeedback(PrivacyModeIsOnFeedbackFunc);
VolumeLevelFeedback = new IntFeedback(VolumeLevelFeedbackFunc);
MuteFeedback = new BoolFeedback(MuteFeedbackFunc);
SharingSourceFeedback = new StringFeedback(SharingSourceFeedbackFunc);
SharingContentIsOnFeedback = new BoolFeedback(SharingContentIsOnFeedbackFunc);
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
ActiveCalls = new List <CodecActiveCallItem>();
}
/// <summary>
/// Constructor for Tesira Dsp Switcher Component
/// </summary>
/// <param name="key">Unique Key</param>
/// <param name="config">Sqitcher Config Object</param>
/// <param name="parent">Parent Object</param>
public TesiraDspSwitcher(string key, TesiraSwitcherControlBlockConfig config, TesiraDsp parent)
: base(config.SwitcherInstanceTag, String.Empty, config.Index1, 0, parent, string.Format(KeyFormatter, parent.Key, key), config.Label, config.BridgeIndex)
{
SourceIndexFeedback = new IntFeedback(Key + "-SourceIndexFeedback", () => SourceIndex);
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
Feedbacks.Add(SourceIndexFeedback);
Feedbacks.Add(NameFeedback);
parent.Feedbacks.AddRange(Feedbacks);
Initialize(config);
}
public HDBaseTRxController(string key, string name, HDRx3CB rmc)
: base(key, name, rmc)
{
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HDBaseTSink = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this)
{
Port = Rmc
};
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HDBaseTSink
};
}
/// <summary>
/// Make a Crestron RMC and put it in here
/// </summary>
public DmRmcX100CController(string key, string name, DmRmc100C rmc)
: base(key, name, rmc)
{
_rmc = rmc;
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this)
{
Port = _rmc
};
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut
};
}
public DmDge200CController(string key, string name, DmDge200C device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
: base(key, name, device, dc, props)
{
_dge = device;
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this);
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut
};
// Set Ports for CEC
HdmiOut.Port = _dge.HdmiOut;;
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="chassis"></param>
public HdMdNxM4kEController(string key, string name, HdMdNxM chassis,
HdMdNxM4kEPropertiesConfig props)
: base(key, name)
{
Chassis = chassis;
// logical ports
InputPorts = new RoutingPortCollection <RoutingInputPort>();
for (uint i = 1; i <= 4; i++)
{
InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, i, this));
}
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this));
// physical settings
if (props != null && props.Inputs != null)
{
foreach (var kvp in props.Inputs)
{
// strip "hdmiIn"
var inputNum = Convert.ToUInt32(kvp.Key.Substring(6));
var port = chassis.HdmiInputs[inputNum].HdmiInputPort;
// set hdcp disables
if (kvp.Value.DisableHdcp)
{
Debug.Console(0, this, "Configuration disables HDCP support on {0}", kvp.Key);
port.HdcpSupportOff();
}
else
{
port.HdcpSupportOn();
}
}
}
}
/// <summary>
/// Make a Crestron RMC and put it in here
/// </summary>
public DmRmc4kScalerCController(string key, string name, DmRmc4kScalerC rmc)
: base(key, name, rmc)
{
_rmc = rmc;
DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.DmCat, 0, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.Hdmi, null, this);
BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
eRoutingPortConnectionType.LineAudio, null, this);
MuteFeedback = new BoolFeedback(() => false);
VolumeLevelFeedback = new IntFeedback("MainVolumeLevelFeedback", () =>
rmc.AudioOutput.VolumeFeedback.UShortValue);
EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
InputPorts = new RoutingPortCollection <RoutingInputPort> {
DmIn
};
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut, BalancedAudioOut
};
VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
_rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
_rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
// Set Ports for CEC
HdmiOut.Port = _rmc.HdmiOutput;
}
public IRBlurayBase(string key, string name, IrOutputPortController portCont)
: base(key, name)
{
IrPort = portCont;
DeviceManager.AddDevice(portCont);
HasKeypadAccessoryButton1 = true;
KeypadAccessoryButton1Command = "Clear";
KeypadAccessoryButton1Label = "Clear";
HasKeypadAccessoryButton2 = true;
KeypadAccessoryButton2Command = "NumericEnter";
KeypadAccessoryButton2Label = "Enter";
PowerIsOnFeedback = new BoolFeedback(() => _PowerIsOn);
HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this);
AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio,
eRoutingPortConnectionType.DigitalAudio, null, this);
OutputPorts = new RoutingPortCollection <RoutingOutputPort> {
HdmiOut, AnyAudioOut
};
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="chassis"></param>
public DmChassisController(string key, string name, DmMDMnxn chassis)
: base(key, name, chassis)
{
Chassis = chassis;
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
VolumeControls = new Dictionary <uint, DmCardAudioOutputController>();
TxDictionary = new Dictionary <uint, string>();
RxDictionary = new Dictionary <uint, string>();
IsOnline.OutputChange += new EventHandler <FeedbackEventArgs>(IsOnline_OutputChange);
Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
VideoOutputFeedbacks = new Dictionary <uint, IntFeedback>();
AudioOutputFeedbacks = new Dictionary <uint, IntFeedback>();
UsbOutputRoutedToFeebacks = new Dictionary <uint, IntFeedback>();
UsbInputRoutedToFeebacks = new Dictionary <uint, IntFeedback>();
OutputDisabledByHdcpFeedbacks = new Dictionary <uint, BoolFeedback>();
VideoInputSyncFeedbacks = new Dictionary <uint, BoolFeedback>();
InputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputVideoRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputAudioRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
InputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
OutputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
SystemIdFeebdack = new IntFeedback(() => { return((Chassis as DmMDMnxn).SystemIdFeedback.UShortValue); });
SystemIdBusyFeedback = new BoolFeedback(() => { return((Chassis as DmMDMnxn).SystemIdBusy.BoolValue); });
InputCardHdcpCapabilityFeedbacks = new Dictionary <uint, IntFeedback>();
InputCardHdcpCapabilityTypes = new Dictionary <uint, eHdcpCapabilityType>();
for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
{
var tempX = x;
if (Chassis.Outputs[tempX] != null)
{
VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].VideoOutFeedback != null)
{
return((ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number);
}
return(0);
});
AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].AudioOutFeedback != null)
{
return((ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number);
}
return(0);
});
UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].USBRoutedToFeedback != null)
{
return((ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number);
}
return(0);
});
OutputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].NameFeedback != null)
{
return(Chassis.Outputs[tempX].NameFeedback.StringValue);
}
return("");
});
OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].VideoOutFeedback != null)
{
return(Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue);
}
return(NoRouteText);
});
OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].AudioOutFeedback != null)
{
return(Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue);
}
return(NoRouteText);
});
OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => Chassis.Outputs[tempX].EndpointOnlineFeedback);
OutputDisabledByHdcpFeedbacks[tempX] = new BoolFeedback(() => {
var output = Chassis.Outputs[tempX];
var hdmiTxOutput = output as Card.HdmiTx;
if (hdmiTxOutput != null)
{
return(hdmiTxOutput.HdmiOutput.DisabledByHdcp.BoolValue);
}
var dmHdmiOutput = output as Card.DmHdmiOutput;
if (dmHdmiOutput != null)
{
return(dmHdmiOutput.DisabledByHdcpFeedback.BoolValue);
}
var dmsDmOutAdvanced = output as Card.DmsDmOutAdvanced;
if (dmsDmOutAdvanced != null)
{
return(dmsDmOutAdvanced.DisabledByHdcpFeedback.BoolValue);
}
var dmps3HdmiAudioOutput = output as Card.Dmps3HdmiAudioOutput;
if (dmps3HdmiAudioOutput != null)
{
return(dmps3HdmiAudioOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue);
}
var dmps3HdmiOutput = output as Card.Dmps3HdmiOutput;
if (dmps3HdmiOutput != null)
{
return(dmps3HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue);
}
var dmps3HdmiOutputBackend = output as Card.Dmps3HdmiOutputBackend;
if (dmps3HdmiOutputBackend != null)
{
return(dmps3HdmiOutputBackend.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue);
}
// var hdRx4kX10HdmiOutput = output as HdRx4kX10HdmiOutput;
// if (hdRx4kX10HdmiOutput != null)
// return hdRx4kX10HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
// var hdMdNxMHdmiOutput = output as HdMdNxMHdmiOutput;
// if (hdMdNxMHdmiOutput != null)
// return hdMdNxMHdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
return(false);
});
}
if (Chassis.Inputs[tempX] != null)
{
UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => {
if (Chassis.Inputs[tempX].USBRoutedToFeedback != null)
{
return((ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number);
}
return(0);
});
VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
if (Chassis.Inputs[tempX].VideoDetectedFeedback != null)
{
return(Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue);
}
return(false);
});
InputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Inputs[tempX].NameFeedback != null)
{
return(Chassis.Inputs[tempX].NameFeedback.StringValue);
}
return("");
});
InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return(Chassis.Inputs[tempX].EndpointOnlineFeedback); });
InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => {
var inputCard = Chassis.Inputs[tempX];
if (inputCard.Card is DmcHd)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
if ((inputCard.Card as DmcHd).HdmiInput.HdcpSupportOnFeedback.BoolValue)
{
return(1);
}
return(0);
}
if (inputCard.Card is DmcHdDsp)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
if ((inputCard.Card as DmcHdDsp).HdmiInput.HdcpSupportOnFeedback.BoolValue)
{
return(1);
}
return(0);
}
if (inputCard.Card is Dmc4kHdBase)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
return((int)(inputCard.Card as Dmc4kHdBase).HdmiInput.HdcpReceiveCapability);
}
if (inputCard.Card is Dmc4kCBase)
{
if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
return((int)(inputCard.Card as Dmc4kCBase).DmInput.HdcpReceiveCapability);
}
if ((inputCard.Card as Dmc4kCBase).DmInput.HdcpSupportOnFeedback.BoolValue)
{
return(1);
}
return(0);
}
if (inputCard.Card is Dmc4kCDspBase)
{
if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
return((int)(inputCard.Card as Dmc4kCDspBase).DmInput.HdcpReceiveCapability);
}
if ((inputCard.Card as Dmc4kCDspBase).DmInput.HdcpSupportOnFeedback.BoolValue)
{
return(1);
}
return(0);
}
return(0);
});
}
}
}
public HdMdxxxCEController(string key, string name, HdMdxxxCE txRxPair)
: base(key, name, txRxPair)
{
TxRxPair = txRxPair;
RemoteEndDetectedFeedback = new BoolFeedback(() => TxRxPair.RemoteEndDetectedOnFeedback.BoolValue);
AutoRouteOnFeedback = new BoolFeedback(() => TxRxPair.TransmitterAutoModeOnFeedback.BoolValue);
PriorityRoutingOnFeedback = new BoolFeedback(() => TxRxPair.PriorityRoutingOnFeedback.BoolValue);
InputOnScreenDisplayEnabledFeedback = new BoolFeedback(() => TxRxPair.OnScreenDisplayEnabledFeedback.BoolValue);
InputPorts = new RoutingPortCollection <RoutingInputPort>();
SyncDetectedFeedbacks = new Dictionary <uint, BoolFeedback>();
// Add the HDMI input port on the receiver
InputPorts.Add(new RoutingInputPort(DmPortName.Hdmi, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 1, this));
SyncDetectedFeedbacks.Add(1, new BoolFeedback(() => TxRxPair.HdmiInputs[1].VideoDetectedFeedback.BoolValue));
if (txRxPair is HdMd400CE)
{
InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2, this));
SyncDetectedFeedbacks.Add(2, new BoolFeedback(() => TxRxPair.HdmiInputs[2].VideoDetectedFeedback.BoolValue));
InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 3, this));
SyncDetectedFeedbacks.Add(3, new BoolFeedback(() => TxRxPair.HdmiInputs[3].VideoDetectedFeedback.BoolValue));
InputPorts.Add(new RoutingInputPort(DmPortName.VgaIn, eRoutingSignalType.Video | eRoutingSignalType.Audio,
eRoutingPortConnectionType.Vga, 4, this));
SyncDetectedFeedbacks.Add(4, new BoolFeedback(() => TxRxPair.VgaInputs[1].VideoDetectedFeedback.BoolValue));
// Set Ports for CEC
InputPorts[DmPortName.HdmiIn1].Port = TxRxPair.HdmiInputs[1];
InputPorts[DmPortName.HdmiIn2].Port = TxRxPair.HdmiInputs[2];
}
else if (txRxPair is HdMd300CE)
{
InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2, this));
SyncDetectedFeedbacks.Add(2, new BoolFeedback(() => TxRxPair.HdmiInputs[2].VideoDetectedFeedback.BoolValue));
InputPorts.Add(new RoutingInputPort(DmPortName.VgaIn, eRoutingSignalType.Video | eRoutingSignalType.Audio,
eRoutingPortConnectionType.Vga, 3, this));
SyncDetectedFeedbacks.Add(3, new BoolFeedback(() => TxRxPair.VgaInputs[1].VideoDetectedFeedback.BoolValue));
// Set Ports for CEC
InputPorts[DmPortName.HdmiIn].Port = TxRxPair.HdmiInputs[1];
}
else if (txRxPair is HdMd200CE || txRxPair is HdMd200C1GE)
{
InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2, this));
SyncDetectedFeedbacks.Add(2, new BoolFeedback(() => TxRxPair.HdmiInputs[2].VideoDetectedFeedback.BoolValue));
// Set Ports for CEC
InputPorts[DmPortName.HdmiIn].Port = TxRxPair.HdmiInputs[1];
}
//ToRx = new RoutingOutputPort(DmPortName.ToTx, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.DmCat, null, this);
//FromTx = new RoutingInputPort(DmPortName.FromTx, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.DmCat, null, this);
HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, null, this);
OutputPorts[DmPortName.HdmiOut].Port = TxRxPair.HdmiOutputs[1];
TxRxPair.DMInputChange += new DMInputEventHandler(TxRxPair_DMInputChange);
TxRxPair.DMOutputChange += new DMOutputEventHandler(TxRxPair_DMOutputChange);
TxRxPair.DMSystemChange += new DMSystemEventHandler(TxRxPair_DMSystemChange);
VideoSourceFeedback = new IntFeedback(() => (int)TxRxPair.HdmiOutputs[1].VideoOutFeedback.Number);
}
public BlueJeansPc(string key, string name)
: base(key, name)
{
InputPorts = new RoutingPortCollection <RoutingInputPort>();
InputPorts.Add(AnyVideoIn = new RoutingInputPort(RoutingPortNames.AnyVideoIn, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this));
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="chassis"></param>
public DmBladeChassisController(string key, string name, BladeSwitch chassis)
: base(key, name, chassis)
{
Chassis = chassis;
InputPorts = new RoutingPortCollection <RoutingInputPort>();
OutputPorts = new RoutingPortCollection <RoutingOutputPort>();
VolumeControls = new Dictionary <uint, DmCardAudioOutputController>();
TxDictionary = new Dictionary <uint, string>();
RxDictionary = new Dictionary <uint, string>();
IsOnline.OutputChange += new EventHandler <FeedbackEventArgs>(IsOnline_OutputChange);
Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
VideoOutputFeedbacks = new Dictionary <uint, IntFeedback>();
UsbOutputRoutedToFeebacks = new Dictionary <uint, IntFeedback>();
UsbInputRoutedToFeebacks = new Dictionary <uint, IntFeedback>();
VideoInputSyncFeedbacks = new Dictionary <uint, BoolFeedback>();
InputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputVideoRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
OutputAudioRouteNameFeedbacks = new Dictionary <uint, StringFeedback>();
InputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
OutputEndpointOnlineFeedbacks = new Dictionary <uint, BoolFeedback>();
InputCardHdcpCapabilityFeedbacks = new Dictionary <uint, IntFeedback>();
InputCardHdcpCapabilityTypes = new Dictionary <uint, eHdcpCapabilityType>();
for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
{
var tempX = x;
if (Chassis.Outputs[tempX] != null)
{
VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].VideoOutFeedback != null)
{
return((ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number);
}
else
{
return(0);
};
});
OutputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].NameFeedback != null)
{
return(Chassis.Outputs[tempX].NameFeedback.StringValue);
}
else
{
return("");
}
});
OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].VideoOutFeedback != null)
{
return(Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue);
}
else
{
return("");
}
});
OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => {
//if (Chassis.Outputs[tempX].Endpoint != null)
// return Chassis.Outputs[tempX].Endpoint.IsOnline;
//else
return(Chassis.Outputs[tempX].EndpointOnlineFeedback);
});
}
if (Chassis.Inputs[tempX] != null)
{
UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => {
if (Chassis.Inputs[tempX].USBRoutedToFeedback != null)
{
return((ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number);
}
else
{
return(0);
};
});
VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
if (Chassis.Inputs[tempX].VideoDetectedFeedback != null)
{
return(Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue);
}
else
{
return(false);
}
});
InputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Inputs[tempX].NameFeedback != null)
{
return(Chassis.Inputs[tempX].NameFeedback.StringValue);
}
else
{
return("");
}
});
InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => {
return(Chassis.Inputs[tempX].EndpointOnlineFeedback);
});
InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => {
var inputCard = Chassis.Inputs[tempX];
if (inputCard.Card is DmHdmi4kInputBladeCard)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
if ((inputCard.Card as DmHdmi4kInputBladeCard).Hdmi4kInput.HdcpSupportOnFeedback.BoolValue)
{
return(1);
}
else
{
return(0);
}
}
if (inputCard.Card is DmC4kInputBladeCard)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
if ((inputCard.Card as DmC4kInputBladeCard).DmInput.HdcpCapabilityFeedback.Equals(eHdcpCapabilityType.HdcpSupportOff))
{
return(0);
}
else
{
return(1);
}
}
else
{
return(0);
}
});
}
}
}