pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-02-12 11:15:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removes essentials-framework as a submodule and brings the files back into the main repo

Browse Source
This commit is contained in:
Neil Dorin
2019-07-09 17:21:53 -06:00
parent 2cd68d40dc
commit 48c6bb78bc
362 changed files with 54624 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
essentials-framework/Essentials DM/Essentials_DM/Chassis/._DmChassisController.cs Normal file
View File

Binary file not shown.

116
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput.cs Normal file
View File

@@ -0,0 +1,116 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = Output.Volume.UShortValue / 65535;
Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
}
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
Output.Volume.CreateRamp(65535, 400);
}
else
Output.Volume.StopRamp();
}
#endregion
}
}

120
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput.cs.orig Normal file
View File

@@ -0,0 +1,120 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
<<<<<<< HEAD
{
var remainingRatio = Output.Volume.UShortValue / 65535;
Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
}
=======
Output.Volume.CreateRamp(0, 400);
>>>>>>> origin/feature/fusion-nyu
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
Output.Volume.CreateRamp(65535, 400);
}
else
Output.Volume.StopRamp();
}
#endregion
}
}

120
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput_BACKUP_14408.cs Normal file
View File

@@ -0,0 +1,120 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
<<<<<<< HEAD
{
var remainingRatio = Output.Volume.UShortValue / 65535;
Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
}
=======
Output.Volume.CreateRamp(0, 400);
>>>>>>> origin/feature/fusion-nyu
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
Output.Volume.CreateRamp(65535, 400);
}
else
Output.Volume.StopRamp();
}
#endregion
}
}

111
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput_BASE_14408.cs Normal file
View File

@@ -0,0 +1,111 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
Output.Volume.CreateRamp(0, 400);
#warning SCALE THIS RAMP
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
Output.Volume.CreateRamp(65535, 400);
else
Output.Volume.StopRamp();
}
#endregion
}
}

116
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput_LOCAL_14408.cs Normal file
View File

@@ -0,0 +1,116 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = Output.Volume.UShortValue / 65535;
Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
}
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
{
var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
Output.Volume.CreateRamp(65535, 400);
}
else
Output.Volume.StopRamp();
}
#endregion
}
}

110
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput_REMOTE_14408.cs Normal file
View File

@@ -0,0 +1,110 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public class DmCardAudioOutputController : IBasicVolumeWithFeedback
{
public Audio.Output Output { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public BoolFeedback MuteFeedback { get; private set; }
ushort PreMuteVolumeLevel;
bool IsMuted;
public DmCardAudioOutputController(Audio.Output output)
{
Output = output;
VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
MuteFeedback = new BoolFeedback(() => IsMuted);
}
#region IBasicVolumeWithFeedback Members
/// <summary>
///
/// </summary>
public void MuteOff()
{
SetVolume(PreMuteVolumeLevel);
IsMuted = false;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void MuteOn()
{
PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
SetVolume(0);
IsMuted = true;
MuteFeedback.FireUpdate();
}
/// <summary>
///
/// </summary>
public void SetVolume(ushort level)
{
Debug.Console(2, "Set volume out {0}", level);
Output.Volume.UShortValue = level;
}
/// <summary>
///
/// </summary>
internal void VolumeEventFromChassis()
{
VolumeLevelFeedback.FireUpdate();
}
#endregion
#region IBasicVolumeControls Members
/// <summary>
///
/// </summary>
public void MuteToggle()
{
if (IsMuted)
MuteOff();
else
MuteOn();
}
/// <summary>
///
/// </summary>
public void VolumeDown(bool pressRelease)
{
if (pressRelease)
Output.Volume.CreateRamp(0, 400);
else
Output.Volume.StopRamp();
}
/// <summary>
///
/// </summary>
public void VolumeUp(bool pressRelease)
{
if (pressRelease)
Output.Volume.CreateRamp(65535, 400);
else
Output.Volume.StopRamp();
}
#endregion
}
}

808
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs Normal file
View File

@@ -0,0 +1,808 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DM;
using Crestron.SimplSharpPro.DM.Cards;
using Crestron.SimplSharpPro.DM.Endpoints;
using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM.Cards;
using PepperDash.Essentials.DM.Config;
namespace PepperDash.Essentials.DM
{
/// <summary>
/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
///
/// </summary>
public class DmChassisController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback//, ICardPortsDevice
{
public DmMDMnxn Chassis { get; private set; }
// Feedbacks for EssentialDM
public Dictionary<uint, IntFeedback> VideoOutputFeedbacks { get; private set; }
public Dictionary<uint, IntFeedback> AudioOutputFeedbacks { get; private set; }
public Dictionary<uint, BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
public Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; private set; }
public Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; private set; }
public Dictionary<uint, StringFeedback> InputNameFeedbacks { get; private set; }
public Dictionary<uint, StringFeedback> OutputNameFeedbacks { get; private set; }
public Dictionary<uint, StringFeedback> OutputVideoRouteNameFeedbacks { get; private set; }
public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
// Need a couple Lists of generic Backplane ports
public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
public Dictionary<uint, string> TxDictionary { get; set; }
public Dictionary<uint, string> RxDictionary { get; set; }
//public Dictionary<uint, DmInputCardControllerBase> InputCards { get; private set; }
//public Dictionary<uint, DmSingleOutputCardControllerBase> OutputCards { get; private set; }
public Dictionary<uint, string> InputNames { get; set; }
public Dictionary<uint, string> OutputNames { get; set; }
public Dictionary<uint, DmCardAudioOutputController> VolumeControls { get; private set; }
public const int RouteOffTime = 500;
Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
/// <summary>
/// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
/// </summary>
public static DmChassisController GetDmChassisController(string key, string name,
string type, DMChassisPropertiesConfig properties)
{
try
{
type = type.ToLower();
uint ipid = properties.Control.IpIdInt;
DmMDMnxn chassis = null;
if (type == "dmmd8x8") { chassis = new DmMd8x8(ipid, Global.ControlSystem); }
else if (type == "dmmd8x8rps") { chassis = new DmMd8x8rps(ipid, Global.ControlSystem); }
else if (type == "dmmd8x8cpu3") { chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem); }
else if (type == "dmmd8x8cpu3rps") { chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem); }
else if (type == "dmmd16x16") { chassis = new DmMd16x16(ipid, Global.ControlSystem); }
else if (type == "dmmd16x16rps") { chassis = new DmMd16x16rps(ipid, Global.ControlSystem); }
else if (type == "dmmd16x16cpu3") { chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem); }
else if (type == "dmmd16x16cpu3rps") { chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem); }
else if (type == "dmmd32x32") { chassis = new DmMd32x32(ipid, Global.ControlSystem); }
else if (type == "dmmd32x32rps") { chassis = new DmMd32x32rps(ipid, Global.ControlSystem); }
else if (type == "dmmd32x32cpu3") { chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem); }
else if (type == "dmmd32x32cpu3rps") { chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem); }
if (chassis == null)
{
return null;
}
var controller = new DmChassisController(key, name, chassis);
// add the cards and port names
foreach (var kvp in properties.InputSlots)
controller.AddInputCard(kvp.Value, kvp.Key);
foreach (var kvp in properties.OutputSlots)
{
controller.AddOutputCard(kvp.Value, kvp.Key);
}
foreach (var kvp in properties.VolumeControls)
{
// get the card
// check it for an audio-compatible type
// make a something-something that will make it work
// retire to mountain village
var outNum = kvp.Key;
var card = controller.Chassis.Outputs[outNum].Card;
Audio.Output audio = null;
if (card is DmcHdo)
audio = (card as DmcHdo).Audio;
else if (card is Dmc4kHdo)
audio = (card as Dmc4kHdo).Audio;
if (audio == null)
continue;
// wire up the audio to something here...
controller.AddVolumeControl(outNum, audio);
}
controller.InputNames = properties.InputNames;
controller.OutputNames = properties.OutputNames;
return controller;
//DmChassisController controller = null;
//if (type == "dmmd8x8")
//{
// controller = new DmChassisController(key, name, new DmMd8x8(ipid, Global.ControlSystem));
// // add the cards and port names
// foreach (var kvp in properties.InputSlots)
// controller.AddInputCard(kvp.Value, kvp.Key);
// foreach (var kvp in properties.OutputSlots)
// {
// controller.AddOutputCard(kvp.Value, kvp.Key);
// }
// foreach (var kvp in properties.VolumeControls)
// {
// // get the card
// // check it for an audio-compatible type
// // make a something-something that will make it work
// // retire to mountain village
// var outNum = kvp.Key;
// var card = controller.Chassis.Outputs[outNum].Card;
// Audio.Output audio = null;
// if (card is DmcHdo)
// audio = (card as DmcHdo).Audio;
// else if (card is Dmc4kHdo)
// audio = (card as Dmc4kHdo).Audio;
// if (audio == null)
// continue;
// // wire up the audio to something here...
// controller.AddVolumeControl(outNum, audio);
// }
// controller.InputNames = properties.InputNames;
// controller.OutputNames = properties.OutputNames;
// return controller;
//}
//else if (type == "dmmd16x16")
//{
// controller = new DmChassisController(key, name, new DmMd16x16(ipid, Global.ControlSystem));
// // add the cards and port names
// foreach (var kvp in properties.InputSlots)
// controller.AddInputCard(kvp.Value, kvp.Key);
// foreach (var kvp in properties.OutputSlots)
// {
// controller.AddOutputCard(kvp.Value, kvp.Key);
// }
// foreach (var kvp in properties.VolumeControls)
// {
// // get the card
// // check it for an audio-compatible type
// // make a something-something that will make it work
// // retire to mountain village
// var outNum = kvp.Key;
// var card = controller.Chassis.Outputs[outNum].Card;
// Audio.Output audio = null;
// if (card is DmcHdo)
// audio = (card as DmcHdo).Audio;
// else if (card is Dmc4kHdo)
// audio = (card as Dmc4kHdo).Audio;
// if (audio == null)
// continue;
// // wire up the audio to something here...
// controller.AddVolumeControl(outNum, audio);
// }
// controller.InputNames = properties.InputNames;
// controller.OutputNames = properties.OutputNames;
// return controller;
//}
}
catch (System.Exception e)
{
Debug.Console(0, "Error creating DM chassis:\r{0}", e);
}
return null;
}
/// <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);
//IsOnline.OutputChange += new EventHandler<EventArgs>(this.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>();
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>();
for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
{
var tempX = x;
VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;}
else { return 0; };
});
AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; }
else { return 0; };
});
VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
});
InputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Inputs[tempX].NameFeedback.StringValue != null)
{
return Chassis.Inputs[tempX].NameFeedback.StringValue;
}
else
{
return "";
}
});
OutputNameFeedbacks[tempX] = new StringFeedback(() => {
if (Chassis.Outputs[tempX].NameFeedback.StringValue != 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 "";
}
});
OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
{
if (Chassis.Outputs[tempX].AudioOutFeedback != null)
{
return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
}
else
{
return "";
}
});
InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Outputs[tempX].EndpointOnlineFeedback; });
}
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="number"></param>
public void AddInputCard(string type, uint number)
{
Debug.Console(2, this, "Adding input card '{0}', slot {1}", type, number);
if (type == "dmcHd")
{
var inputCard = new DmcHd(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmcHdDsp")
{
var inputCard = new DmcHdDsp(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmc4kHd")
{
var inputCard = new Dmc4kHd(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmc4kHdDsp")
{
var inputCard = new Dmc4kHdDsp(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmc4kzHd")
{
var inputCard = new Dmc4kzHd(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmc4kzHdDsp")
{
var inputCard = new Dmc4kzHdDsp(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort);
}
else if (type == "dmcC")
{
new DmcC(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmcCDsp")
{
new DmcCDsp(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmc4kC")
{
new Dmc4kC(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmc4kCDsp")
{
new Dmc4kCDsp(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmc4kzC")
{
new Dmc4kzC(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmc4kzCDsp")
{
new Dmc4kzCDsp(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmcCat")
{
new DmcCat(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmcCatDsp")
{
new DmcCatDsp(number, this.Chassis);
AddDmInCardPorts(number);
}
else if (type == "dmcS")
{
new DmcS(number, Chassis);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
AddInCardHdmiAndAudioLoopPorts(number);
}
else if (type == "dmcSDsp")
{
new DmcSDsp(number, Chassis);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
AddInCardHdmiAndAudioLoopPorts(number);
}
else if (type == "dmcS2")
{
new DmcS2(number, Chassis);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
AddInCardHdmiAndAudioLoopPorts(number);
}
else if (type == "dmcS2Dsp")
{
new DmcS2Dsp(number, Chassis);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
AddInCardHdmiAndAudioLoopPorts(number);
}
else if (type == "dmcSdi")
{
new DmcSdi(number, Chassis);
AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi);
AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi, null);
AddInCardHdmiAndAudioLoopPorts(number);
}
else if (type == "dmcDvi")
{
new DmcDvi(number, Chassis);
AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Dvi);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcVga")
{
new DmcVga(number, Chassis);
AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcVidBnc")
{
new DmcVidBnc(number, Chassis);
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcVidRcaA")
{
new DmcVidRcaA(number, Chassis);
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcVidRcaD")
{
new DmcVidRcaD(number, Chassis);
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcVid4")
{
new DmcVid4(number, Chassis);
AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInCardHdmiLoopPort(number);
}
else if (type == "dmcStr")
{
new DmcStr(number, Chassis);
AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
AddInCardHdmiAndAudioLoopPorts(number);
}
}
void AddDmInCardPorts(uint number)
{
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
AddInCardHdmiAndAudioLoopPorts(number);
}
void AddHdmiInCardPorts(uint number, ICec cecPort)
{
AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
AddInCardHdmiAndAudioLoopPorts(number);
}
void AddInCardHdmiAndAudioLoopPorts(uint number)
{
AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
}
void AddInCardHdmiLoopPort(uint number)
{
AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="number"></param>
public void AddOutputCard(string type, uint number)
{
Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
if (type == "dmc4kHdo")
{
var outputCard = new Dmc4kHdoSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
else if (type == "dmcHdo")
{
var outputCard = new DmcHdoSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
else if (type == "dmc4kCoHd")
{
var outputCard = new Dmc4kCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmc4kzCoHd")
{
var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmcCoHd")
{
var outputCard = new DmcCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmCatoHd")
{
var outputCard = new DmcCatoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmcSoHd")
{
var outputCard = new DmcSoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
}
else if (type == "dmcS2oHd")
{
var outputCard = new DmcS2oHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
}
else if (type == "dmcStro")
{
var outputCard = new DmcStroSingle(number, Chassis);
AddOutputPortWithDebug(number, "streamOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
}
else
Debug.Console(1, this, " WARNING: Output card type '{0}' is not available", type);
}
void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
{
AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(number, "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
AddOutputPortWithDebug(number, "hdmiOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
AddOutputPortWithDebug(number, "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
}
void AddDmcCoPorts(uint number, ICec cecPort1)
{
AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
}
/// <summary>
/// Adds InputPort
/// </summary>
void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType)
{
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
InputPorts.Add(inputPort);
}
/// <summary>
/// Adds InputPort and sets Port as ICec object
/// </summary>
void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, ICec cecPort)
{
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
if (cecPort != null)
inputPort.Port = cecPort;
InputPorts.Add(inputPort);
}
/// <summary>
/// Adds OutputPort
/// </summary>
void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
{
var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding output port '{0}'", portKey);
OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
}
/// <summary>
/// Adds OutputPort and sets Port as ICec object
/// </summary>
void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
{
var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding output port '{0}'", portKey);
var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);
if (cecPort != null)
outputPort.Port = cecPort;
OutputPorts.Add(outputPort);
}
/// <summary>
///
/// </summary>
void AddVolumeControl(uint number, Audio.Output audio)
{
VolumeControls.Add(number, new DmCardAudioOutputController(audio));
}
//public void SetInputHdcpSupport(uint input, ePdtHdcpSupport hdcpSetting)
//{
//}
void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) {
}
void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
//Debug.Console(2, this, "DMSwitch:{0} Input:{1} Event:{2}'", this.Name, args.Number, args.EventId.ToString());
switch (args.EventId) {
case (DMInputEventIds.OnlineFeedbackEventId): {
Debug.Console(2, this, "DMINput OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
break;
}
case (DMInputEventIds.VideoDetectedEventId): {
Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
VideoInputSyncFeedbacks[args.Number].FireUpdate();
break;
}
case (DMInputEventIds.InputNameEventId): {
Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
InputNameFeedbacks[args.Number].FireUpdate();
break;
}
}
}
///
/// </summary>
void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
{
//This should be a switch case JTA 2018-07-02
var output = args.Number;
if (args.EventId == DMOutputEventIds.VolumeEventId &&
VolumeControls.ContainsKey(output))
{
VolumeControls[args.Number].VolumeEventFromChassis();
}
else if (args.EventId == DMOutputEventIds.OnlineFeedbackEventId)
{
OutputEndpointOnlineFeedbacks[output].FireUpdate();
}
else if (args.EventId == DMOutputEventIds.VideoOutEventId)
{
if (Chassis.Outputs[output].VideoOutFeedback != null)
{
Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
}
if (VideoOutputFeedbacks.ContainsKey(output))
{
VideoOutputFeedbacks[output].FireUpdate();
}
if (OutputVideoRouteNameFeedbacks.ContainsKey(output))
{
OutputVideoRouteNameFeedbacks[output].FireUpdate();
}
}
else if (args.EventId == DMOutputEventIds.AudioOutEventId)
{
if (Chassis.Outputs[output].AudioOutFeedback != null)
{
Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
}
if (AudioOutputFeedbacks.ContainsKey(output))
{
AudioOutputFeedbacks[output].FireUpdate();
}
}
else if (args.EventId == DMOutputEventIds.OutputNameEventId)
{
Debug.Console(2, this, "DM Output {0} NameFeedbackEventId", output);
OutputNameFeedbacks[output].FireUpdate();
}
}
/// <summary>
///
/// </summary>
/// <param name="pnt"></param>
void StartOffTimer(PortNumberType pnt)
{
if (RouteOffTimers.ContainsKey(pnt))
return;
RouteOffTimers[pnt] = new CTimer(o =>
{
ExecuteSwitch(0, pnt.Number, pnt.Type);
}, RouteOffTime);
}
// Send out sigs when coming online
void IsOnline_OutputChange(object sender, EventArgs e)
{
if (IsOnline.BoolValue)
{
Chassis.EnableAudioBreakaway.BoolValue = true;
//Chassis.EnableUSBBreakaway.BoolValue = true;
if (InputNames != null)
foreach (var kvp in InputNames)
Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
if (OutputNames != null)
foreach(var kvp in OutputNames)
Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
}
}
#region IRouting Members
public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
{
Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
var output = Convert.ToUInt32(outputSelector);
// Check to see if there's an off timer waiting on this and if so, cancel
var key = new PortNumberType(output, sigType);
if (input == 0)
{
StartOffTimer(key);
}
else
{
if(RouteOffTimers.ContainsKey(key))
{
Debug.Console(2, this, "{0} cancelling route off due to new source", output);
RouteOffTimers[key].Stop();
RouteOffTimers.Remove(key);
}
}
Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
// NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
if (sigType != eRoutingSignalType.Audio)
{
Chassis.VideoEnter.BoolValue = true;
Chassis.Outputs[output].VideoOut = inCard;
}
if (sigType != eRoutingSignalType.Video)
{
Chassis.AudioEnter.BoolValue = true;
Chassis.Outputs[output].AudioOut = inCard;
}
}
#endregion
}
public struct PortNumberType
{
public uint Number { get; private set; }
public eRoutingSignalType Type { get; private set; }
public PortNumberType(uint number, eRoutingSignalType type) : this()
{
Number = number;
Type = type;
}
}
}

125
essentials-framework/Essentials DM/Essentials_DM/Chassis/HdMdNxM4kEController.cs Normal file
View File

@@ -0,0 +1,125 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM.Config;
namespace PepperDash.Essentials.DM.Chassis
{
public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
{
public HdMdNxM Chassis { get; private set; }
public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
/// <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.AudioVideo,
eRoutingPortConnectionType.Hdmi, i, this));
}
OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
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();
}
}
}
public override bool CustomActivate()
{
var result = Chassis.Register();
if (result != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
{
Debug.Console(0, this, "Device registration failed: {0}", result);
return false;
}
return base.CustomActivate();
}
#region IRouting Members
public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
{
// Try to make switch only when necessary. The unit appears to toggle when already selected.
var current = Chassis.HdmiOutputs[1].VideoOut;
if(current != Chassis.HdmiInputs[(uint)inputSelector])
Chassis.HdmiOutputs[1].VideoOut = Chassis.HdmiInputs[(uint)inputSelector];
}
#endregion
/////////////////////////////////////////////////////
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="name"></param>
/// <param name="type"></param>
/// <param name="properties"></param>
/// <returns></returns>
public static HdMdNxM4kEController GetController(string key, string name,
string type, HdMdNxM4kEPropertiesConfig properties)
{
try
{
var ipid = properties.Control.IpIdInt;
var address = properties.Control.TcpSshProperties.Address;
type = type.ToLower();
if (type == "hdmd4x14ke")
{
var chassis = new HdMd4x14kE(ipid, address, Global.ControlSystem);
return new HdMdNxM4kEController(key, name, chassis, properties);
}
return null;
}
catch (Exception e)
{
Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
return null;
}
}
}
}