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

Merge branch 'development' into feature/fix-namespaces

Browse Source
This commit is contained in:
Andrew Welker
2021-02-22 15:34:22 -07:00
committed by GitHub
parent 52c96cc2c3 10046a9ed4
commit e06be3ebe9
3 changed files with 494 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmBladeChassisController.cs
View File

@@ -23,6 +23,8 @@ namespace PepperDash.Essentials.DM {
/// </summary> /// </summary>
public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
{ {
private const string NonePortKey = "inputCard0--None";
public DMChassisPropertiesConfig PropertiesConfig { get; set; } public DMChassisPropertiesConfig PropertiesConfig { get; set; }
public Switch Chassis { get; private set; } public Switch Chassis { get; private set; }
@@ -112,6 +114,10 @@ namespace PepperDash.Essentials.DM {
controller.AddVolumeControl(outNum, audio); controller.AddVolumeControl(outNum, audio);
} }
controller.InputPorts.Add(new RoutingInputPort(NonePortKey, eRoutingSignalType.Video,
eRoutingPortConnectionType.None, null, controller));
controller.InputNames = properties.InputNames; controller.InputNames = properties.InputNames;
controller.OutputNames = properties.OutputNames; controller.OutputNames = properties.OutputNames;
controller.PropertiesConfig = properties; controller.PropertiesConfig = properties;
@@ -367,34 +373,28 @@ namespace PepperDash.Essentials.DM {
} }
void AddHdmiOutBladePorts(uint number) { void AddHdmiOutBladePorts(uint number) {
AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("hdmiOut{0}", number) , eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, number); AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("hdmiOut{0}", number) , eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, Chassis.Outputs[number]);
} }
void AddDmOutBladePorts(uint number) { void AddDmOutBladePorts(uint number) {
AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, number); AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, Chassis.Outputs[number]);
} }
void AddDmOutMmFiberBladePorts(uint number) { void AddDmOutMmFiberBladePorts(uint number) {
AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, number); AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, Chassis.Outputs[number]);
} }
void AddDmOutSmFiberBladePorts(uint number) { void AddDmOutSmFiberBladePorts(uint number) {
AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, number); AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, Chassis.Outputs[number]);
} }
/// <summary> /// <summary>
/// Adds InputPort /// Adds InputPort
/// </summary> /// </summary>
void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType) { 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); AddInputPortWithDebug(cardNum, portName, sigType, portType, null);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this)
{
FeedbackMatchObject = Chassis.Inputs[cardNum]
};
InputPorts.Add(inputPort);
} }
/// <summary> /// <summary>
@@ -405,7 +405,7 @@ namespace PepperDash.Essentials.DM {
{ {
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName); var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding input port '{0}'", portKey); Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this) var inputPort = new RoutingInputPort(portKey, sigType, portType, Chassis.Inputs[cardNum], this)
{ {
FeedbackMatchObject = Chassis.Inputs[cardNum] FeedbackMatchObject = Chassis.Inputs[cardNum]
}; };
@@ -567,9 +567,7 @@ namespace PepperDash.Essentials.DM {
void StartOffTimer(PortNumberType pnt) { void StartOffTimer(PortNumberType pnt) {
if (RouteOffTimers.ContainsKey(pnt)) if (RouteOffTimers.ContainsKey(pnt))
return; return;
RouteOffTimers[pnt] = new CTimer(o => { RouteOffTimers[pnt] = new CTimer(o => ExecuteSwitch(null, pnt.Selector, pnt.Type), RouteOffTime);
ExecuteSwitch(0, pnt.Number, pnt.Type);
}, RouteOffTime);
} }
@@ -592,11 +590,22 @@ namespace PepperDash.Essentials.DM {
public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType) { 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); 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 input = inputSelector as DMInput; // Cast can sometimes fail
var output = Convert.ToUInt32(outputSelector); var output = outputSelector as DMOutput;
if (output == null)
{
Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
"Unable to execute switch for inputSelector {0} to outputSelector {1}", inputSelector,
outputSelector);
return;
}
// Check to see if there's an off timer waiting on this and if so, cancel // Check to see if there's an off timer waiting on this and if so, cancel
var key = new PortNumberType(output, sigType); var key = new PortNumberType(output, sigType);
if (input == 0) {
if (input == null) {
StartOffTimer(key); StartOffTimer(key);
} }
else { else {
@@ -609,13 +618,13 @@ namespace PepperDash.Essentials.DM {
var inCard = input == 0 ? null : Chassis.Inputs[input]; /*var inCard = input == 0 ? null : Chassis.Inputs[input];
var outCard = input == 0 ? null : Chassis.Outputs[output]; var outCard = input == 0 ? null : Chassis.Outputs[output];*/
// NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES
if ((sigType | eRoutingSignalType.Video) != eRoutingSignalType.Video) return; if ((sigType & eRoutingSignalType.Video) != eRoutingSignalType.Video) return;
Chassis.VideoEnter.BoolValue = true; Chassis.VideoEnter.BoolValue = true;
Chassis.Outputs[output].VideoOut = inCard; output.VideoOut = input;
} }
#endregion #endregion
@@ -624,7 +633,10 @@ namespace PepperDash.Essentials.DM {
public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType) public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType)
{ {
ExecuteSwitch(inputSelector, outputSelector, sigType); var input = inputSelector == 0 ? null : Chassis.Inputs[inputSelector];
var output = Chassis.Outputs[outputSelector];
ExecuteSwitch(input, output, sigType);
} }
#endregion #endregion

696
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs
View File

@@ -23,6 +23,7 @@ namespace PepperDash.Essentials.DM
[Description("Wrapper class for all DM-MD chassis variants from 8x8 to 32x32")] [Description("Wrapper class for all DM-MD chassis variants from 8x8 to 32x32")]
public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
{ {
private const string NonePortKey = "inputCard0--None";
public DMChassisPropertiesConfig PropertiesConfig { get; set; } public DMChassisPropertiesConfig PropertiesConfig { get; set; }
public Switch Chassis { get; private set; } public Switch Chassis { get; private set; }
@@ -133,6 +134,12 @@ namespace PepperDash.Essentials.DM
var controller = new DmChassisController(key, name, chassis); var controller = new DmChassisController(key, name, chassis);
//
var clearInputPort = new RoutingInputPort(NonePortKey, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.None, null, controller);
controller.InputPorts.Add(clearInputPort);
// add the cards and port names // add the cards and port names
foreach (var kvp in properties.InputSlots) foreach (var kvp in properties.InputSlots)
controller.AddInputCard(kvp.Value, kvp.Key); controller.AddInputCard(kvp.Value, kvp.Key);
@@ -485,169 +492,170 @@ namespace PepperDash.Essentials.DM
type = type.ToLower(); type = type.ToLower();
if (type == "dmchd") switch (type)
{ {
var inputCard = new DmcHd(number, this.Chassis); case "dmchd":
var cecPort = inputCard.HdmiInput as ICec; {
AddHdmiInCardPorts(number, cecPort); var inputCard = new DmcHd(number, this.Chassis);
} var cecPort = inputCard.HdmiInput as ICec;
else if (type == "dmchddsp") AddHdmiInCardPorts(number, cecPort);
{ }
var inputCard = new DmcHdDsp(number, this.Chassis); break;
var cecPort = inputCard.HdmiInput as ICec; case "dmchddsp":
AddHdmiInCardPorts(number, cecPort); {
} var inputCard = new DmcHdDsp(number, this.Chassis);
else if (type == "dmc4khd") var cecPort = inputCard.HdmiInput as ICec;
{ AddHdmiInCardPorts(number, cecPort);
var inputCard = new Dmc4kHd(number, this.Chassis); }
var cecPort = inputCard.HdmiInput as ICec; break;
AddHdmiInCardPorts(number, cecPort); case "dmc4khd":
} {
else if (type == "dmc4khddsp") var inputCard = new Dmc4kHd(number, this.Chassis);
{ var cecPort = inputCard.HdmiInput as ICec;
var inputCard = new Dmc4kHdDsp(number, this.Chassis); AddHdmiInCardPorts(number, cecPort);
var cecPort = inputCard.HdmiInput as ICec; }
AddHdmiInCardPorts(number, cecPort); break;
} case "dmc4khddsp":
else if (type == "dmc4kzhd") {
{ var inputCard = new Dmc4kHdDsp(number, this.Chassis);
var inputCard = new Dmc4kzHd(number, this.Chassis); var cecPort = inputCard.HdmiInput as ICec;
var cecPort = inputCard.HdmiInput as ICec; AddHdmiInCardPorts(number, cecPort);
AddHdmiInCardPorts(number, cecPort); }
} break;
else if (type == "dmc4kzhddsp") case "dmc4kzhd":
{ {
var inputCard = new Dmc4kzHdDsp(number, this.Chassis); var inputCard = new Dmc4kzHd(number, this.Chassis);
var cecPort = inputCard.HdmiInput as ICec; var cecPort = inputCard.HdmiInput as ICec;
AddHdmiInCardPorts(number, cecPort); AddHdmiInCardPorts(number, cecPort);
} }
else if (type == "dmcc") break;
{ case "dmc4kzhddsp":
var inputCard = new DmcC(number, this.Chassis); {
var cecPort = inputCard.DmInput as ICec; var inputCard = new Dmc4kzHdDsp(number, this.Chassis);
AddDmInCardPorts(number, cecPort); var cecPort = inputCard.HdmiInput as ICec;
} AddHdmiInCardPorts(number, cecPort);
else if (type == "dmccdsp") }
{ break;
var inputCard = new DmcCDsp(number, this.Chassis); case "dmcc":
var cecPort = inputCard.DmInput as ICec; {
AddDmInCardPorts(number, cecPort); var inputCard = new DmcC(number, this.Chassis);
} var cecPort = inputCard.DmInput as ICec;
else if (type == "dmc4kc") AddDmInCardPorts(number, cecPort);
{ }
var inputCard = new Dmc4kC(number, this.Chassis); break;
var cecPort = inputCard.DmInput as ICec; case "dmccdsp":
AddDmInCardPorts(number, cecPort); {
} var inputCard = new DmcCDsp(number, this.Chassis);
else if (type == "dmc4kcdsp") var cecPort = inputCard.DmInput as ICec;
{ AddDmInCardPorts(number, cecPort);
var inputCard = new Dmc4kCDsp(number, this.Chassis); }
var cecPort = inputCard.DmInput as ICec; break;
AddDmInCardPorts(number, cecPort); case "dmc4kc":
} {
else if (type == "dmc4kzc") var inputCard = new Dmc4kC(number, this.Chassis);
{ var cecPort = inputCard.DmInput as ICec;
var inputCard = new Dmc4kzC(number, this.Chassis); AddDmInCardPorts(number, cecPort);
var cecPort = inputCard.DmInput as ICec; }
AddDmInCardPorts(number, cecPort); break;
} case "dmc4kcdsp":
else if (type == "dmc4kzcdsp") {
{ var inputCard = new Dmc4kCDsp(number, this.Chassis);
var inputCard = new Dmc4kzCDsp(number, this.Chassis); var cecPort = inputCard.DmInput as ICec;
var cecPort = inputCard.DmInput as ICec; AddDmInCardPorts(number, cecPort);
AddDmInCardPorts(number, cecPort); }
} break;
else if (type == "dmccat") case "dmc4kzc":
{ {
new DmcCat(number, this.Chassis); var inputCard = new Dmc4kzC(number, this.Chassis);
AddDmInCardPorts(number); var cecPort = inputCard.DmInput as ICec;
} AddDmInCardPorts(number, cecPort);
else if (type == "dmccatdsp") }
{ break;
new DmcCatDsp(number, this.Chassis); case "dmc4kzcdsp":
AddDmInCardPorts(number); {
} var inputCard = new Dmc4kzCDsp(number, this.Chassis);
else if (type == "dmcs") var cecPort = inputCard.DmInput as ICec;
{ AddDmInCardPorts(number, cecPort);
new DmcS(number, Chassis); }
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber); break;
AddInCardHdmiAndAudioLoopPorts(number); case "dmccat":
} new DmcCat(number, this.Chassis);
else if (type == "dmcsdsp") AddDmInCardPorts(number);
{ break;
new DmcSDsp(number, Chassis); case "dmccatdsp":
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber); new DmcCatDsp(number, this.Chassis);
AddInCardHdmiAndAudioLoopPorts(number); AddDmInCardPorts(number);
} break;
else if (type == "dmcs2") case "dmcs":
{ new DmcS(number, Chassis);
new DmcS2(number, Chassis); AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber); AddInCardHdmiAndAudioLoopPorts(number);
AddInCardHdmiAndAudioLoopPorts(number); break;
} case "dmcsdsp":
else if (type == "dmcs2dsp") new DmcSDsp(number, Chassis);
{ AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
new DmcS2Dsp(number, Chassis); AddInCardHdmiAndAudioLoopPorts(number);
AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber); break;
AddInCardHdmiAndAudioLoopPorts(number); case "dmcs2":
} new DmcS2(number, Chassis);
else if (type == "dmcsdi") AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
{ AddInCardHdmiAndAudioLoopPorts(number);
new DmcSdi(number, Chassis); break;
AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi); case "dmcs2dsp":
AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, new DmcS2Dsp(number, Chassis);
eRoutingPortConnectionType.Sdi, null); AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
AddInCardHdmiAndAudioLoopPorts(number); AddInCardHdmiAndAudioLoopPorts(number);
} break;
else if (type == "dmcdvi") case "dmcsdi":
{ new DmcSdi(number, Chassis);
new DmcDvi(number, Chassis); AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Dvi); AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio); eRoutingPortConnectionType.Sdi, null);
AddInCardHdmiLoopPort(number); AddInCardHdmiAndAudioLoopPorts(number);
} break;
else if (type == "dmcvga") case "dmcdvi":
{ new DmcDvi(number, Chassis);
new DmcVga(number, Chassis); AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Dvi);
AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga); AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio); AddInCardHdmiLoopPort(number);
AddInCardHdmiLoopPort(number); break;
} case "dmcvga":
else if (type == "dmcvidbnc") new DmcVga(number, Chassis);
{ AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga);
new DmcVidBnc(number, Chassis); AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component); AddInCardHdmiLoopPort(number);
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio); break;
AddInCardHdmiLoopPort(number); case "dmcvidbnc":
} new DmcVidBnc(number, Chassis);
else if (type == "dmcvidrcaa") AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
{ AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
new DmcVidRcaA(number, Chassis); AddInCardHdmiLoopPort(number);
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component); break;
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio); case "dmcvidrcaa":
AddInCardHdmiLoopPort(number); new DmcVidRcaA(number, Chassis);
} AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
else if (type == "dmcvidrcad") AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
{ AddInCardHdmiLoopPort(number);
new DmcVidRcaD(number, Chassis); break;
AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component); case "dmcvidrcad":
AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio); new DmcVidRcaD(number, Chassis);
AddInCardHdmiLoopPort(number); AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
} AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio);
else if (type == "dmcvid4") AddInCardHdmiLoopPort(number);
{ break;
new DmcVid4(number, Chassis); case "dmcvid4":
AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite); new DmcVid4(number, Chassis);
AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite); AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite); AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite); AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
AddInCardHdmiLoopPort(number); AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
} AddInCardHdmiLoopPort(number);
else if (type == "dmcstr") break;
{ case "dmcstr":
new DmcStr(number, Chassis); new DmcStr(number, Chassis);
AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming); AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
AddInCardHdmiAndAudioLoopPorts(number); AddInCardHdmiAndAudioLoopPorts(number);
break;
} }
} }
@@ -692,104 +700,114 @@ namespace PepperDash.Essentials.DM
type = type.ToLower(); type = type.ToLower();
Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number); Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
if (type == "dmc4khdo") switch (type)
{ {
var outputCard = new Dmc4kHdoSingle(number, Chassis); case "dmc4khdo":
var cecPort1 = outputCard.Card1.HdmiOutput; {
var cecPort2 = outputCard.Card2.HdmiOutput; var outputCard = new Dmc4kHdoSingle(number, Chassis);
AddDmcHdoPorts(number, cecPort1, cecPort2); var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
break;
case "dmc4kzhdo":
{
var outputCard = new Dmc4kzHdoSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
break;
case "dmchdo":
{
var outputCard = new DmcHdoSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
break;
case "dmc4kcohd":
{
var outputCard = new Dmc4kCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
break;
case "dmc4kzcohd":
{
var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
break;
case "dmccohd":
{
var outputCard = new DmcCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
break;
case "dmccatohd":
{
var outputCard = new DmcCatoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
break;
case "dmcsohd":
{
var outputCard = new DmcSoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmMmFiber, Chassis.Outputs[2 * (number - 1) + 1]);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, Chassis.Outputs[2 * (number - 1) + 1], cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmMmFiber, Chassis.Outputs[2 * (number - 1) + 2]);
}
break;
case "dmcs2ohd":
{
var outputCard = new DmcS2oHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmSmFiber, Chassis.Outputs[2 * (number - 1) + 1]);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, Chassis.Outputs[2 * (number - 1) + 1], cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmSmFiber, Chassis.Outputs[2 * (number - 1) + 2]);
}
break;
case "dmcstro":
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Streaming, Chassis.Outputs[2 * (number - 1) + 1]);
break;
default:
Debug.Console(1, this, " WARNING: Output card type '{0}' is not available", type);
break;
} }
else if (type == "dmc4kzhdo")
{
var outputCard = new Dmc4kzHdoSingle(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 == "dmccatohd")
{
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(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
}
else if (type == "dmcs2ohd")
{
var outputCard = new DmcS2oHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
}
else if (type == "dmcstro")
{
var outputCard = new DmcStroSingle(number, Chassis);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
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) void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
{ {
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1); eRoutingPortConnectionType.Hdmi, Chassis.Outputs[2 * (number - 1) + 1], cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio,
2 * (number - 1) + 1); Chassis.Outputs[2 * (number - 1) + 1]);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2); eRoutingPortConnectionType.Hdmi, Chassis.Outputs[2 * (number - 1) + 2], cecPort2);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio,
2 * (number - 1) + 2); Chassis.Outputs[2 * (number - 1) + 2]);
} }
void AddDmcCoPorts(uint number, ICec cecPort1) void AddDmcCoPorts(uint number, ICec cecPort1)
{ {
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1); eRoutingPortConnectionType.DmCat, Chassis.Outputs[2 * (number - 1) + 1]);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1); eRoutingPortConnectionType.Hdmi, Chassis.Outputs[2 * (number - 1) + 1], cecPort1);
AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2); eRoutingPortConnectionType.DmCat, Chassis.Outputs[2 * (number - 1) + 2]);
} }
/// <summary> /// <summary>
@@ -797,14 +815,7 @@ namespace PepperDash.Essentials.DM
/// </summary> /// </summary>
void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType) void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType)
{ {
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName); AddInputPortWithDebug(cardNum, portName, sigType, portType, null);
Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this)
{
FeedbackMatchObject = Chassis.Inputs[cardNum]
};
InputPorts.Add(inputPort);
} }
/// <summary> /// <summary>
@@ -814,7 +825,7 @@ namespace PepperDash.Essentials.DM
{ {
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName); var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding input port '{0}'", portKey); Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this) var inputPort = new RoutingInputPort(portKey, sigType, portType, Chassis.Inputs[cardNum], this)
{ {
FeedbackMatchObject = Chassis.Inputs[cardNum] FeedbackMatchObject = Chassis.Inputs[cardNum]
}; ; }; ;
@@ -830,17 +841,7 @@ namespace PepperDash.Essentials.DM
/// </summary> /// </summary>
void AddOutputPortWithDebug(string cardName, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector) void AddOutputPortWithDebug(string cardName, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
{ {
var portKey = string.Format("{0}--{1}", cardName, portName); AddOutputPortWithDebug(cardName, portName, sigType, portType, selector, null);
Debug.Console(2, this, "Adding output port '{0}'", portKey);
var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);
if (portName.IndexOf("Loop", StringComparison.InvariantCultureIgnoreCase) < 0)
{
outputPort.FeedbackMatchObject = Chassis.Outputs[(uint) selector];
}
OutputPorts.Add(outputPort);
} }
/// <summary> /// <summary>
@@ -854,7 +855,7 @@ namespace PepperDash.Essentials.DM
if (portName.IndexOf("Loop", StringComparison.InvariantCultureIgnoreCase) < 0) if (portName.IndexOf("Loop", StringComparison.InvariantCultureIgnoreCase) < 0)
{ {
outputPort.FeedbackMatchObject = Chassis.Outputs[(uint)selector]; outputPort.FeedbackMatchObject = selector;
} }
if (cecPort != null) if (cecPort != null)
outputPort.Port = cecPort; outputPort.Port = cecPort;
@@ -1144,7 +1145,7 @@ namespace PepperDash.Essentials.DM
{ {
if (RouteOffTimers.ContainsKey(pnt)) if (RouteOffTimers.ContainsKey(pnt))
return; return;
RouteOffTimers[pnt] = new CTimer(o => { ExecuteSwitch(0, pnt.Number, pnt.Type); }, RouteOffTime); RouteOffTimers[pnt] = new CTimer(o => ExecuteSwitch(null, pnt.Selector, pnt.Type), RouteOffTime);
} }
// Send out sigs when coming online // Send out sigs when coming online
@@ -1173,16 +1174,22 @@ namespace PepperDash.Essentials.DM
{ {
Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, 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 input = inputSelector as DMInput;//Input Selector could be null...
var output = Convert.ToUInt32(outputSelector);
var chassisSize = (uint) Chassis.NumberOfInputs; //need this to determine USB routing values 8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8 var output = outputSelector as DMOutput;
//16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
//32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32 if (output == null)
{
Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
"Unable to execute switch for inputSelector {0} to outputSelector {1}", inputSelector,
outputSelector);
return;
}
// Check to see if there's an off timer waiting on this and if so, cancel // Check to see if there's an off timer waiting on this and if so, cancel
var key = new PortNumberType(output, sigType); var key = new PortNumberType(output, sigType);
if (input == 0) if (input == null)
{ {
StartOffTimer(key); StartOffTimer(key);
} }
@@ -1196,30 +1203,75 @@ namespace PepperDash.Essentials.DM
} }
} }
var inCard = input == 0 ? null : Chassis.Inputs[input]; //var inCard = input == 0 ? null : Chassis.Inputs[input];
var outCard = input == 0 ? null : Chassis.Outputs[output]; //var outCard = input == 0 ? null : Chassis.Outputs[output];
// NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES
if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video) if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video)
{ {
Chassis.VideoEnter.BoolValue = true; Chassis.VideoEnter.BoolValue = true;
Chassis.Outputs[output].VideoOut = inCard; output.VideoOut = input; //Chassis.Outputs[output].VideoOut = inCard;
} }
if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio) if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
{ {
(Chassis as DmMDMnxn).AudioEnter.BoolValue = true; var dmMdMnxn = Chassis as DmMDMnxn;
Chassis.Outputs[output].AudioOut = inCard; if (dmMdMnxn != null)
{
dmMdMnxn.AudioEnter.BoolValue = true;
}
output.VideoOut = input;
//Chassis.Outputs[output].AudioOut = inCard;
} }
if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput || (sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
{
Chassis.USBEnter.BoolValue = true;
output.USBRoutedTo = input;
}
}
#endregion
#region IRoutingNumeric Members
public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType)
{
var chassisSize = (uint)Chassis.NumberOfInputs; //need this to determine USB routing values 8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8
//16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
//32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32
DMInputOutputBase dmCard;
if ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
{
if (outputSelector > chassisSize)
{
uint outputIndex;
if (chassisSize == 8)
{
outputIndex = (uint) inputSelector - 16;
}
else
{
outputIndex = inputSelector - chassisSize;
}
dmCard = Chassis.Outputs[outputIndex];
}
else
{
dmCard = Chassis.Inputs[inputSelector];
}
ExecuteSwitch(dmCard, Chassis.Outputs[outputSelector], sigType);
return;
}
if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput) if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
{ {
//using base here because USB can be routed between 2 output cards or 2 input cards Debug.Console(2, this, "Executing USB Output switch.\r\n in:{0} output: {1}", inputSelector, outputSelector);
DMInputOutputBase dmCard;
Debug.Console(2, this, "Executing USB Output switch.\r\n in:{0} output: {1}", input, output); if (inputSelector > chassisSize)
if (input > chassisSize)
{ {
//wanting to route an output to an output. Subtract chassis size and get output, unless it's 8x8 //wanting to route an output to an output. Subtract chassis size and get output, unless it's 8x8
//need this to determine USB routing values //need this to determine USB routing values
@@ -1230,76 +1282,30 @@ namespace PepperDash.Essentials.DM
if (chassisSize == 8) if (chassisSize == 8)
{ {
outputIndex = input - 16; outputIndex = (uint) inputSelector - 16;
} }
else else
{ {
outputIndex = input - chassisSize; outputIndex = inputSelector - chassisSize;
} }
dmCard = Chassis.Outputs[outputIndex]; dmCard = Chassis.Outputs[outputIndex];
} }
else else
{ {
dmCard = inCard; dmCard = Chassis.Inputs[inputSelector];
} }
Chassis.USBEnter.BoolValue = true; Chassis.USBEnter.BoolValue = true;
if (Chassis.Outputs[output] != null)
{ Debug.Console(2, this, "Routing USB for input {0} to {1}", inputSelector, dmCard);
Debug.Console(2, this, "Routing USB for input {0} to {1}", Chassis.Outputs[input], dmCard); ExecuteSwitch(dmCard, Chassis.Outputs[outputSelector], sigType);
Chassis.Outputs[output].USBRoutedTo = dmCard; return;
}
} }
if ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput) var inputCard = inputSelector == 0 ? null : Chassis.Inputs[inputSelector];
{ var outputCard = Chassis.Outputs[outputSelector];
//using base here because USB can be routed between 2 output cards or 2 input cards
DMInputOutputBase dmCard;
Debug.Console(2, this, "Executing USB Input switch.\r\n in:{0} output: {1}", input, output); ExecuteSwitch(inputCard, outputCard, sigType);
if (output > chassisSize)
{
//wanting to route an input to an output. Subtract chassis size and get output, unless it's 8x8
//need this to determine USB routing values
//8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8
//16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
//32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32
uint outputIndex;
if (chassisSize == 8)
{
outputIndex = input - 16;
}
else
{
outputIndex = input - chassisSize;
}
dmCard = Chassis.Outputs[outputIndex];
}
else
{
dmCard = Chassis.Inputs[input];
}
Chassis.USBEnter.BoolValue = true;
if (Chassis.Inputs[output] == null)
{
return;
}
Debug.Console(2, this, "Routing USB for input {0} to {1}", Chassis.Inputs[output], dmCard);
Chassis.Inputs[output].USBRoutedTo = dmCard;
}
}
#endregion
#region IRoutingNumeric Members
public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType)
{
ExecuteSwitch(inputSelector, outputSelector, sigType);
} }
#endregion #endregion
@@ -1850,13 +1856,23 @@ namespace PepperDash.Essentials.DM
public struct PortNumberType public struct PortNumberType
{ {
public uint Number { get; private set; } public uint Number { get; private set; }
public object Selector { get; private set; }
public eRoutingSignalType Type { get; private set; } public eRoutingSignalType Type { get; private set; }
public PortNumberType(uint number, eRoutingSignalType type) public PortNumberType(object selector, eRoutingSignalType type)
: this() : this()
{ {
Number = number; Selector = selector;
Type = type; Type = type;
if (Selector is DMOutput)
{
Number = (selector as DMOutput).Number;
}
else if (Selector is uint)
{
Number = (uint) selector;
}
} }
} }

145
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmpsRoutingController.cs
View File

@@ -21,6 +21,8 @@ namespace PepperDash.Essentials.DM
{ {
public class DmpsRoutingController : EssentialsBridgeableDevice, IRoutingNumericWithFeedback, IHasFeedback public class DmpsRoutingController : EssentialsBridgeableDevice, IRoutingNumericWithFeedback, IHasFeedback
{ {
private const string NonePortKey = "none";
public CrestronControlSystem Dmps { get; set; } public CrestronControlSystem Dmps { get; set; }
public ISystemControl SystemControl { get; private set; } public ISystemControl SystemControl { get; private set; }
@@ -75,20 +77,18 @@ namespace PepperDash.Essentials.DM
{ {
try try
{ {
var systemControl = Global.ControlSystem.SystemControl;
ISystemControl systemControl = null;
systemControl = Global.ControlSystem.SystemControl as ISystemControl;
if (systemControl == null) if (systemControl == null)
{ {
return null; return null;
} }
var controller = new DmpsRoutingController(key, name, systemControl); var controller = new DmpsRoutingController(key, name, systemControl)
{
controller.InputNames = properties.InputNames; InputNames = properties.InputNames,
controller.OutputNames = properties.OutputNames; OutputNames = properties.OutputNames
};
if (!string.IsNullOrEmpty(properties.NoRouteText)) if (!string.IsNullOrEmpty(properties.NoRouteText))
controller.NoRouteText = properties.NoRouteText; controller.NoRouteText = properties.NoRouteText;
@@ -96,9 +96,9 @@ namespace PepperDash.Essentials.DM
return controller; return controller;
} }
catch (System.Exception e) catch (Exception e)
{ {
Debug.Console(0, "Error getting DMPS Controller:\r{0}", e); Debug.Console(0, "Error getting DMPS Controller:\r\n{0}", e);
} }
return null; return null;
} }
@@ -113,6 +113,7 @@ namespace PepperDash.Essentials.DM
public DmpsRoutingController(string key, string name, ISystemControl systemControl) public DmpsRoutingController(string key, string name, ISystemControl systemControl)
: base(key, name) : base(key, name)
{ {
Dmps = Global.ControlSystem; Dmps = Global.ControlSystem;
SystemControl = systemControl; SystemControl = systemControl;
@@ -427,14 +428,11 @@ namespace PepperDash.Essentials.DM
{ {
Debug.Console(1, this, "Adding Input Card Number {0} Type: {1}", inputCard.Number, inputCard.CardInputOutputType.ToString()); Debug.Console(1, this, "Adding Input Card Number {0} Type: {1}", inputCard.Number, inputCard.CardInputOutputType.ToString());
InputEndpointOnlineFeedbacks[inputCard.Number] = new BoolFeedback(() => { return inputCard.EndpointOnlineFeedback; }); InputEndpointOnlineFeedbacks[inputCard.Number] = new BoolFeedback(() => inputCard.EndpointOnlineFeedback);
if (inputCard.VideoDetectedFeedback != null) if (inputCard.VideoDetectedFeedback != null)
{ {
VideoInputSyncFeedbacks[inputCard.Number] = new BoolFeedback(() => VideoInputSyncFeedbacks[inputCard.Number] = new BoolFeedback(() => inputCard.VideoDetectedFeedback.BoolValue);
{
return inputCard.VideoDetectedFeedback.BoolValue;
});
} }
InputNameFeedbacks[inputCard.Number] = new StringFeedback(() => InputNameFeedbacks[inputCard.Number] = new StringFeedback(() =>
@@ -443,13 +441,10 @@ namespace PepperDash.Essentials.DM
{ {
Debug.Console(2, this, "Input Card {0} Name: {1}", inputCard.Number, inputCard.NameFeedback.StringValue); Debug.Console(2, this, "Input Card {0} Name: {1}", inputCard.Number, inputCard.NameFeedback.StringValue);
return inputCard.NameFeedback.StringValue; return inputCard.NameFeedback.StringValue;
}
} Debug.Console(2, this, "Input Card {0} Name is null", inputCard.Number);
else return "";
{
Debug.Console(2, this, "Input Card {0} Name is null", inputCard.Number);
return "";
}
}); });
AddInputCard(inputCard.Number, inputCard); AddInputCard(inputCard.Number, inputCard);
@@ -459,6 +454,9 @@ namespace PepperDash.Essentials.DM
Debug.Console(2, this, "***********Input Card of type {0} is cannot be cast as DMInput*************", card.CardInputOutputType); Debug.Console(2, this, "***********Input Card of type {0} is cannot be cast as DMInput*************", card.CardInputOutputType);
} }
} }
InputPorts.Add(new RoutingInputPort(NonePortKey, eRoutingSignalType.AudioVideo,
eRoutingPortConnectionType.None, null, this));
} }
/// <summary> /// <summary>
@@ -531,15 +529,7 @@ namespace PepperDash.Essentials.DM
private void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, private void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType,
eRoutingPortConnectionType portType) eRoutingPortConnectionType portType)
{ {
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName); AddInputPortWithDebug(cardNum, portName, sigType, portType, null);
Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this)
{
FeedbackMatchObject = Dmps.SwitcherInputs[cardNum]
};
;
InputPorts.Add(inputPort);
} }
/// <summary> /// <summary>
@@ -549,11 +539,10 @@ namespace PepperDash.Essentials.DM
{ {
var portKey = string.Format("inputCard{0}--{1}", cardNum, portName); var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
Debug.Console(2, this, "Adding input port '{0}'", portKey); Debug.Console(2, this, "Adding input port '{0}'", portKey);
var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this) var inputPort = new RoutingInputPort(portKey, sigType, portType, Dmps.SwitcherInputs[cardNum], this)
{ {
FeedbackMatchObject = Dmps.SwitcherInputs[cardNum] FeedbackMatchObject = Dmps.SwitcherInputs[cardNum]
}; };
;
if (cecPort != null) if (cecPort != null)
inputPort.Port = cecPort; inputPort.Port = cecPort;
@@ -672,7 +661,7 @@ namespace PepperDash.Essentials.DM
/// <param name="number"></param> /// <param name="number"></param>
void AddAudioOnlyOutputPort(uint number, string portName) void AddAudioOnlyOutputPort(uint number, string portName)
{ {
AddOutputPortWithDebug(number, portName, eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, number); AddOutputPortWithDebug(number, portName, eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, Dmps.SwitcherOutputs[number]);
} }
/// <summary> /// <summary>
@@ -682,7 +671,7 @@ namespace PepperDash.Essentials.DM
/// <param name="cecPort"></param> /// <param name="cecPort"></param>
void AddHdmiOutputPort(uint number, ICec cecPort) void AddHdmiOutputPort(uint number, ICec cecPort)
{ {
AddOutputPortWithDebug(number, string.Format("hdmiOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, number, cecPort); AddOutputPortWithDebug(number, string.Format("hdmiOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, Dmps.SwitcherOutputs[number], cecPort);
} }
/// <summary> /// <summary>
@@ -691,7 +680,7 @@ namespace PepperDash.Essentials.DM
/// <param name="number"></param> /// <param name="number"></param>
void AddDmOutputPort(uint number) void AddDmOutputPort(uint number)
{ {
AddOutputPortWithDebug(number, string.Format("dmOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, number); AddOutputPortWithDebug(number, string.Format("dmOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, Dmps.SwitcherOutputs[number]);
} }
/// <summary> /// <summary>
@@ -699,12 +688,7 @@ namespace PepperDash.Essentials.DM
/// </summary> /// </summary>
void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector) void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
{ {
var portKey = string.Format("outputCard{0}--{1}", cardNum, portName); AddOutputPortWithDebug(cardNum, portName, sigType, portType, selector, null);
Debug.Console(2, this, "Adding output port '{0}'", portKey);
OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this)
{
FeedbackMatchObject = Dmps.SwitcherOutputs[cardNum]
});
} }
/// <summary> /// <summary>
@@ -848,21 +832,32 @@ namespace PepperDash.Essentials.DM
Debug.Console(2, this, "Attempting a DM route from input {0} to output {1} {2}", inputSelector, outputSelector, sigType); Debug.Console(2, this, "Attempting a DM route from input {0} to output {1} {2}", inputSelector, outputSelector, sigType);
var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail //var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
var output = Convert.ToUInt32(outputSelector); //var output = Convert.ToUInt32(outputSelector);
var input = inputSelector as DMInput;
var output = outputSelector as DMOutput;
if (output == null)
{
Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
"Unable to execute switch for inputSelector {0} to outputSelector {1}", inputSelector,
outputSelector);
return;
}
var sigTypeIsUsbOrVideo = ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video) || var sigTypeIsUsbOrVideo = ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video) ||
((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput) || ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput) ||
((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput); ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput);
if ((input <= Dmps.NumberOfSwitcherInputs && output <= Dmps.NumberOfSwitcherOutputs && if (input == null || (input.Number <= Dmps.NumberOfSwitcherInputs && output.Number <= Dmps.NumberOfSwitcherOutputs &&
sigTypeIsUsbOrVideo) || sigTypeIsUsbOrVideo) ||
(input <= Dmps.NumberOfSwitcherInputs + 5 && output <= Dmps.NumberOfSwitcherOutputs && (input.Number <= Dmps.NumberOfSwitcherInputs + 5 && output.Number <= Dmps.NumberOfSwitcherOutputs &&
(sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio)) (sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio))
{ {
// Check to see if there's an off timer waiting on this and if so, cancel // Check to see if there's an off timer waiting on this and if so, cancel
var key = new PortNumberType(output, sigType); var key = new PortNumberType(output, sigType);
if (input == 0) if (input == null)
{ {
StartOffTimer(key); StartOffTimer(key);
} }
@@ -877,60 +872,47 @@ namespace PepperDash.Essentials.DM
} }
DMOutput dmOutputCard = output == 0 ? null : Dmps.SwitcherOutputs[output] as DMOutput; //DMOutput dmOutputCard = output == 0 ? null : Dmps.SwitcherOutputs[output] as DMOutput;
//if (inCard != null) //if (inCard != null)
//{ //{
// NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES
if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video) if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video)
{ {
DMInput dmInputCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput;
//SystemControl.VideoEnter.BoolValue = true; output.VideoOut = input;
if (dmOutputCard != null)
dmOutputCard.VideoOut = dmInputCard;
} }
if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio) if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
{ {
DMInput dmInputCard = null; try
if (input <= Dmps.NumberOfSwitcherInputs)
{ {
dmInputCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput; output.AudioOut = input;
} }
catch (NotSupportedException)
{
Debug.Console(1, this, "Routing input {0} audio to output {1}",
(eDmps34KAudioOutSource) (input == null ? 0 : input.Number),
(CrestronControlSystem.eDmps34K350COutputs) output.Number);
if (dmOutputCard != null) output.AudioOutSource = input == null
try ? eDmps34KAudioOutSource.NoRoute
{ : (eDmps34KAudioOutSource)input.Number;
dmOutputCard.AudioOut = dmInputCard; }
}
catch (NotSupportedException)
{
Debug.Console(1, this, "Routing input {0} audio to output {1}",
(eDmps34KAudioOutSource) input, (CrestronControlSystem.eDmps34K350COutputs) output);
dmOutputCard.AudioOutSource = (eDmps34KAudioOutSource) input;
}
} }
if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput) if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
{ {
DMInput dmInputCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput;
if (dmOutputCard != null) output.USBRoutedTo = input;
dmOutputCard.USBRoutedTo = dmInputCard;
} }
if ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput) if ((sigType & eRoutingSignalType.UsbInput) != eRoutingSignalType.UsbInput)
{ {
DMInput dmInputCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput; return;
if (dmInputCard != null)
dmInputCard.USBRoutedTo = dmOutputCard;
} }
//} if (input != null)
//else input.USBRoutedTo = output;
//{
// Debug.Console(1, this, "Unable to execute route from input {0} to output {1}. Input card not available", inputSelector, outputSelector);
//}
} }
else else
{ {
@@ -950,7 +932,10 @@ namespace PepperDash.Essentials.DM
public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType) public void ExecuteNumericSwitch(ushort inputSelector, ushort outputSelector, eRoutingSignalType sigType)
{ {
ExecuteSwitch(inputSelector, outputSelector, sigType); var input = inputSelector == 0 ? null : Dmps.SwitcherInputs[inputSelector];
var output = Dmps.SwitcherOutputs[outputSelector];
ExecuteSwitch(input, output, sigType);
} }
#endregion #endregion