Merged in feature/ecs-1140 (pull request #28 )

Feature/ecs 1140 Approved-by: Neil Dorin <ndorin@pepperdash.com>
Merge branch 'feature/ecs-1139' into feature/ecs-1140
2026-01-13 12:35:03 +00:00 · 2019-08-16 05:29:06 +00:00 · 2019-08-15 21:07:16 -06:00 · 2019-08-15 20:56:03 -06:00 · 2019-08-15 14:07:10 -06:00 · 2019-08-14 17:16:17 -06:00
51 changed files with 536 additions and 270 deletions
--- a/PepperDashEssentials/Bridges/DmChassisControllerBridge.cs
+++ b/PepperDashEssentials/Bridges/DmChassisControllerBridge.cs
@@ -5,6 +5,8 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;

 using PepperDash.Core;
 using PepperDash.Essentials.Core;
@@ -27,6 +29,12 @@ namespace PepperDash.Essentials.Bridges

            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);

+            trilist.SetUShortSigAction(joinMap.SystemId, new Action<ushort>(o => dmChassis.Chassis.SystemId.UShortValue = o));
+            trilist.SetSigTrueAction(joinMap.SystemId, new Action(() => dmChassis.Chassis.ApplySystemId()));
+
+            dmChassis.SystemIdFeebdack.LinkInputSig(trilist.UShortInput[joinMap.SystemId]);
+            dmChassis.SystemIdBusyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SystemId]);
+
            // Link up outputs
            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs; i++)
            {
@@ -35,29 +43,75 @@ namespace PepperDash.Essentials.Bridges
                // Control
                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
                trilist.SetUShortSigAction(joinMap.OutputAudio + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Audio)));
+                trilist.SetUShortSigAction(joinMap.OutputUsb + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.UsbOutput)));
+                trilist.SetUShortSigAction(joinMap.InputUsb + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.UsbInput)));
+
 				if (dmChassis.TxDictionary.ContainsKey(ioSlot))
 				{
 					Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
-					var TxKey = dmChassis.TxDictionary[ioSlot];
-					var TxDevice = DeviceManager.GetDeviceForKey(TxKey) as DmTxControllerBase;
+					var txKey = dmChassis.TxDictionary[ioSlot];
+                    var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
+
+					var txDevice = basicTxDevice as DmTxControllerBase;
+
                    if (dmChassis.Chassis is DmMd8x8Cpu3 || dmChassis.Chassis is DmMd8x8Cpu3rps
                        || dmChassis.Chassis is DmMd16x16Cpu3 || dmChassis.Chassis is DmMd16x16Cpu3rps
                        || dmChassis.Chassis is DmMd32x32Cpu3 || dmChassis.Chassis is DmMd32x32Cpu3rps)
                    {
                        dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
                    }
-                    else if (TxDevice != null)
+                    else
                    {
-                        TxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                        if (txDevice != null)
+                        {
+                            txDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                        }
+                    }
+
+                    if(basicTxDevice != null && txDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+
+                    if (txDevice != null)
+                    {
+                        txDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                    }
+                    else
+                    {
+                        var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                        if(inputPort != null)
+                        {
+                            var hdmiInPort = inputPort.Port;
+
+                            if (hdmiInPort != null)
+                            {
+                                if (hdmiInPort is HdmiInputWithCEC)
+                                {
+                                    var hdmiInPortWCec = hdmiInPort as HdmiInputWithCEC;
+
+                                    if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown)
+                                    {
+                                        SetHdcpCapabilityAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                }
+                            }
+                        }
                    }
-					// TxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
-					// trilist.SetUShortSigAction((ApiMap.HdcpSupport[ioSlot]), u => TxDevice.SetHdcpSupportAll((ePdtHdcpSupport)(u)));
-					// TxDevice.HdcpSupportAllFeedback.LinkInputSig(trilist.UShortInput[joinMap. + ioSlot]);
-					// trilist.UShortInput[ApiMap.HdcpSupportCapability[ioSlot]].UShortValue = TxDevice.HdcpSupportCapability;
 				}
 				else
 				{
-					// dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[ApiMap.TxVideoSyncStatus[ioSlot]]);
+					dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                    var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}-hdmiIn", ioSlot)].Port as EndpointHdmiInput;
+
+                    if (inputPort != null)
+                    {
+                        //trilist.SetUShortSigAction((joinMap.HdcpSupport + ioSlot), u => 
+                    }
 				}
 				if (dmChassis.RxDictionary.ContainsKey(ioSlot))
 				{
@@ -78,8 +132,10 @@ namespace PepperDash.Essentials.Bridges
                // Feedback
                dmChassis.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + ioSlot]);
                dmChassis.AudioOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputAudio + ioSlot]);
+                dmChassis.UsbOutputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputUsb + ioSlot]);
+                dmChassis.UsbInputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.InputUsb + ioSlot]);

-                 dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+                dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);

                dmChassis.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
                dmChassis.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
@@ -88,39 +144,118 @@ namespace PepperDash.Essentials.Bridges
            }
        }

+        static void SetHdcpCapabilityAction(bool hdcpTypeSimple, HdmiInputWithCEC port, uint join, BasicTriList trilist)
+        {
+            if (hdcpTypeSimple)
+            {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s =>
+                    {
+                        if (s == 0)
+                        {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0)
+                        {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else
+            {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(s =>
+                        {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)s;
+                        }));
+            }
+        }
+
+        static void SetHdcpCapabilityAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist)
+        {
+            if (hdcpTypeSimple)
+            {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s =>
+                    {
+                        if (s == 0)
+                        {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0)
+                        {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else
+            {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(s =>
+                        {
+                            port.HdcpCapability = (eHdcpCapabilityType)s;
+                        }));
+            }
+        }

        public class DmChassisControllerJoinMap : JoinMapBase
        {
+            //Digital
+            public uint SystemId { get; set; }
            public uint IsOnline { get; set; }
+            public uint OutputUsb { get; set; }
+            public uint InputUsb { get; set; }
+            public uint VideoSyncStatus { get; set; }
+            public uint InputEndpointOnline { get; set; }
+            public uint OutputEndpointOnline { get; set; }
+            public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+
+            //Analog
            public uint OutputVideo { get; set; }
            public uint OutputAudio { get; set; }
-            public uint VideoSyncStatus { get; set; }
+            public uint HdcpSupportState { get; set; }
+            public uint HdcpSupportCapability { get; set; }
+
+            //SErial
            public uint InputNames { get; set; }
            public uint OutputNames { get; set; }
            public uint OutputCurrentVideoInputNames { get; set; }
            public uint OutputCurrentAudioInputNames { get; set; }
            public uint InputCurrentResolution { get; set; }
-            public uint InputEndpointOnline { get; set; }
-            public uint OutputEndpointOnline { get; set; }
-            //public uint HdcpSupport { get; set; }
-            //public uint HdcpSupportCapability { get; set; }
+


            public DmChassisControllerJoinMap()
            {
+                SystemId = 10;
+                //Digital 
                IsOnline = 11;
+                VideoSyncStatus = 100; //101-299
+                InputEndpointOnline = 500; //501-699
+                OutputEndpointOnline = 700; //701-899
+                TxAdvancedIsPresent = 1000; //1001-1199
+
+                //Analog
                OutputVideo = 100; //101-299
                OutputAudio = 300; //301-499
+                OutputUsb = 500; //501-699
+                InputUsb = 700; //701-899
                VideoSyncStatus = 100; //101-299
+                HdcpSupportState = 1000; //1001-1199
+                HdcpSupportCapability = 1200; //1201-1399
+
+
+                //Serial
                InputNames = 100; //101-299
                OutputNames = 300; //301-499
                OutputCurrentVideoInputNames = 2000; //2001-2199
                OutputCurrentAudioInputNames = 2200; //2201-2399
                InputCurrentResolution = 2400; // 2401-2599
-                InputEndpointOnline = 500;
-                OutputEndpointOnline = 700;
-                //HdcpSupport = 1000; //1001-1199
-                //HdcpSupportCapability = 1200; //1201-1399
+                InputEndpointOnline = 500; //501-699
+                OutputEndpointOnline = 700; //701-899
+                HdcpSupportState = 1000; //1001-1199
+                HdcpSupportCapability = 1200; //1201-1399
+

            }

@@ -128,9 +263,12 @@ namespace PepperDash.Essentials.Bridges
            {
                var joinOffset = joinStart - 1;

+                SystemId = SystemId + joinOffset;
                IsOnline = IsOnline + joinOffset;
                OutputVideo = OutputVideo + joinOffset;
                OutputAudio = OutputAudio + joinOffset;
+                OutputUsb = OutputUsb + joinOffset;
+                InputUsb = InputUsb + joinOffset;
                VideoSyncStatus = VideoSyncStatus + joinOffset;
                InputNames = InputNames + joinOffset;
                OutputNames = OutputNames + joinOffset;
@@ -139,8 +277,8 @@ namespace PepperDash.Essentials.Bridges
                InputCurrentResolution = InputCurrentResolution + joinOffset;
                InputEndpointOnline = InputEndpointOnline + joinOffset;
                OutputEndpointOnline = OutputEndpointOnline + joinOffset;
-                //HdcpSupport = HdcpSupport + joinOffset;
-                //HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+                HdcpSupportState = HdcpSupportState + joinOffset;
+                HdcpSupportCapability = HdcpSupportCapability + joinOffset;
            }
        }
    }
--- a/PepperDashEssentials/Bridges/DmTxControllerBridge.cs
+++ b/PepperDashEssentials/Bridges/DmTxControllerBridge.cs
@@ -30,7 +30,7 @@ namespace PepperDash.Essentials.Bridges
            tx.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
            tx.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus]);
            tx.AnyVideoInput.VideoStatus.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution]);
-            //tx.HdcpSupportAllFeedback.LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportCapability]);
+            trilist.UShortInput[joinMap.HdcpSupportCapability].UShortValue = (ushort)tx.HdcpSupportCapability;

            bool hdcpTypeSimple;

--- a/Core/PepperDashEssentialsBase/Display/BasicIrDisplay.cs
+++ b/Core/PepperDashEssentialsBase/Display/BasicIrDisplay.cs
@@ -50,19 +50,19 @@ namespace PepperDash.Essentials.Core

 			InputPorts.AddRange(new RoutingPortCollection<RoutingInputPort>
 			{
-				new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Hdmi1), this, false),
-				new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Hdmi2), this, false),
-				new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Hdmi3), this, false),
-				new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Hdmi4), this, false),
-				new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Component1), this, false),
-				new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Video1), this, false),
-				new RoutingInputPort(RoutingPortNames.AntennaIn, eRoutingSignalType.AudioVideo, 
+				new RoutingInputPort(RoutingPortNames.AntennaIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 					eRoutingPortConnectionType.Hdmi, new Action(Antenna), this, false),
 			});
 		}
--- a/Core/PepperDashEssentialsBase/Display/MockDisplay.cs
+++ b/Core/PepperDashEssentialsBase/Display/MockDisplay.cs
@@ -43,11 +43,11 @@ namespace PepperDash.Essentials.Core
 		public MockDisplay(string key, string name)
 			: base(key, name)
 		{
-			HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+			HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
+			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);
 			ComponentIn1 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Component, null, this);
--- a/Core/PepperDashEssentialsBase/Routing/DummyRoutingInputsDevice.cs
+++ b/Core/PepperDashEssentialsBase/Routing/DummyRoutingInputsDevice.cs
@@ -29,7 +29,7 @@ namespace PepperDash.Essentials.Core.Routing
 		/// <param name="key">key for special device</param>
 		public DummyRoutingInputsDevice(string key) : base(key)
 		{
-			AudioVideoOutputPort = new RoutingOutputPort("internal", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.BackplaneOnly,
+			AudioVideoOutputPort = new RoutingOutputPort("internal", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.BackplaneOnly,
 				null, this, true);
 		}
 	}
--- a/Core/PepperDashEssentialsBase/Routing/IRoutingInputsExtensions.cs
+++ b/Core/PepperDashEssentialsBase/Routing/IRoutingInputsExtensions.cs
@@ -60,7 +60,7 @@ namespace PepperDash.Essentials.Core
 		{
 			var routeDescr = new RouteDescriptor(source, destination, signalType);
 			// if it's a single signal type, find the route
-			if (signalType != eRoutingSignalType.AudioVideo)
+			if ((signalType & (eRoutingSignalType.Audio & eRoutingSignalType.Video)) == (eRoutingSignalType.Audio & eRoutingSignalType.Video))
 			{
 				Debug.Console(1, destination, "Attempting to build source route from {0}", source.Key);
 				if (!destination.GetRouteToSource(source, null, null, signalType, 0, routeDescr))
@@ -106,7 +106,7 @@ namespace PepperDash.Essentials.Core

 			RoutingInputPort goodInputPort = null;
 			var destDevInputTies = TieLineCollection.Default.Where(t =>
-				t.DestinationPort.ParentDevice == destination && (t.Type == signalType || t.Type == eRoutingSignalType.AudioVideo));
+                t.DestinationPort.ParentDevice == destination && (t.Type == signalType || (t.Type & (eRoutingSignalType.Audio | eRoutingSignalType.Video)) == (eRoutingSignalType.Audio | eRoutingSignalType.Video)));

 			// find a direct tie
 			var directTie = destDevInputTies.FirstOrDefault(
--- a/Core/PepperDashEssentialsBase/Routing/RoutingPort.cs
+++ b/Core/PepperDashEssentialsBase/Routing/RoutingPort.cs
@@ -32,8 +32,10 @@ namespace PepperDash.Essentials.Core
 	public enum eRoutingSignalType
 	{
 		Audio = 1,
-		Video = 2,
-		AudioVideo = 4
+		Video = 2,     
+		//AudioVideo = 4,
+        UsbOutput = 4,
+        UsbInput = 8
 	}

 	public enum eRoutingPortConnectionType
--- a/DM/Essentials_DM/AirMedia/AirMediaController.cs
+++ b/DM/Essentials_DM/AirMedia/AirMediaController.cs
@@ -46,13 +46,13 @@ namespace PepperDash.Essentials.DM.AirMedia

            PropertiesConfig = props;

-            InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.AudioVideo,
+            InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.None, new Action(SelectPinPointUxLandingPage), this));

-            InputPorts.Add(new RoutingInputPort(DmPortName.AirMediaIn, eRoutingSignalType.AudioVideo,
+            InputPorts.Add(new RoutingInputPort(DmPortName.AirMediaIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Streaming, new Action(SelectAirMedia), this));

-            InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+            InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(SelectHdmiIn), this));

            InputPorts.Add(new RoutingInputPort(DmPortName.AirBoardIn, eRoutingSignalType.Video,
@@ -60,7 +60,7 @@ namespace PepperDash.Essentials.DM.AirMedia

            if (AirMedia is Am300)
            {
-                InputPorts.Add(new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                InputPorts.Add(new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                    eRoutingPortConnectionType.DmCat, new Action(SelectDmIn), this));
            }

--- a/REMOVE/Dmc4kCoHdSingleOutputCard.cs
+++ b/REMOVE/Dmc4kCoHdSingleOutputCard.cs
@@ -30,11 +30,11 @@ namespace PepperDash.Essentials.DM.Cards
 			: base(key, slot)
 		{
 			Card = card;
-            //DmOut1 = new RoutingOutputPort(DmPortName.DmOut1, eRoutingSignalType.AudioVideo,
+            //DmOut1 = new RoutingOutputPort(DmPortName.DmOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
            //    eRoutingPortConnectionType.DmCat, null, this);
-            //DmOut2 = new RoutingOutputPort(DmPortName.DmOut2, eRoutingSignalType.AudioVideo,
+            //DmOut2 = new RoutingOutputPort(DmPortName.DmOut2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
            //    eRoutingPortConnectionType.DmCat, null, this);
-            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
            //    eRoutingPortConnectionType.Hdmi, null, this);

            //OutputPorts.AddRange(new[] { DmOut1, DmOut2, HdmiOut1 });
--- a/REMOVE/Dmc4kHdoSingleOutputCard.cs
+++ b/REMOVE/Dmc4kHdoSingleOutputCard.cs
@@ -35,9 +35,9 @@
 //            //    eRoutingPortConnectionType.LineAudio, null, this);
 //            //AudioOut2 = new RoutingOutputPort(DmPortName.BalancedAudioOut2, eRoutingSignalType.Audio,
 //            //    eRoutingPortConnectionType.LineAudio, null, this);
-//            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+//            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
-//            //HdmiOut2 = new RoutingOutputPort(DmPortName.HdmiOut2, eRoutingSignalType.AudioVideo,
+//            //HdmiOut2 = new RoutingOutputPort(DmPortName.HdmiOut2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);

 //            //OutputPorts.AddRange(new[] { AudioOut1, AudioOut2, HdmiOut1, HdmiOut2 });
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -29,11 +29,11 @@
 //            : base(key, slot)
 //        {
 //            Card = card;
-//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.DmCat, null, this, 
 //            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));

-//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
 //            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
@@ -59,11 +59,11 @@
 //            : base(key, slot)
 //        {
 //            Card = card;
-//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.DmCat, null, this,
 //            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));

-//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
 //            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -32,11 +32,11 @@
 //            : base(key, slot)
 //        {
 //            Card = card;
-//            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //                eRoutingPortConnectionType.Hdmi, null, this,
 //                VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));

-//            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //                eRoutingPortConnectionType.Hdmi, null, this);
 //            AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
 //                eRoutingPortConnectionType.Hdmi, null, this);
@@ -65,11 +65,11 @@
 //            : base(key, slot)
 //        {
 //            Card = card;
-//            //HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//            //HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this,
 //            //    VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));

-//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
 //            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
 //            //    eRoutingPortConnectionType.Hdmi, null, this);
--- a/DM/Essentials_DM/Chassis/DmChassisController.cs
+++ b/DM/Essentials_DM/Chassis/DmChassisController.cs
@@ -35,6 +35,16 @@ namespace PepperDash.Essentials.DM
 		public Dictionary<uint, StringFeedback> OutputNameFeedbacks { get; private set; }
 		public Dictionary<uint, StringFeedback> OutputVideoRouteNameFeedbacks { get; private set; }
        public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
+        public Dictionary<uint, IntFeedback> UsbOutputRoutedToFeebacks { get; private set; }
+        public Dictionary<uint, IntFeedback> UsbInputRoutedToFeebacks { get; private set; }
+
+        public IntFeedback SystemIdFeebdack { get; private set; }
+        public BoolFeedback SystemIdBusyFeedback { get; private set; }
+
+
+        public Dictionary<uint, IntFeedback> InputCardHdcpCapabilityFeedbacks { get; private set; }
+
+        public Dictionary<uint, eHdcpCapabilityType> InputCardHdcpCapabilityTypes { get; private set; }
 		
 		
 		// Need a couple Lists of generic Backplane ports
@@ -143,10 +153,12 @@ namespace PepperDash.Essentials.DM
 			RxDictionary = new Dictionary<uint, string>();
 			IsOnline.OutputChange += new EventHandler<FeedbackEventArgs>(IsOnline_OutputChange);
 			Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
-			//Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
+			Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
            Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
 			VideoOutputFeedbacks = new Dictionary<uint, IntFeedback>();
 			AudioOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+            UsbOutputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
+            UsbInputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
 			VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
 			InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
 			OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
@@ -155,6 +167,11 @@ namespace PepperDash.Essentials.DM
            InputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
            OutputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();

+            SystemIdFeebdack = new IntFeedback(() => { return Chassis.SystemIdFeedback.UShortValue; });
+            SystemIdBusyFeedback = new BoolFeedback(() => { return Chassis.SystemIdBusy.BoolValue; });
+            InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
+            InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
+

 			for (uint x = 1; x <= Chassis.NumberOfOutputs; x++) 
            {
@@ -168,6 +185,14 @@ namespace PepperDash.Essentials.DM
 					if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; } 
 					else { return 0; };
 					});
+                UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() => { 
+                    if(Chassis.Outputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number; }
+                    else {return 0; };
+                    });
+                UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => { 
+                    if(Chassis.Inputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number; }
+                    else {return 0; };
+                    });
 				VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {			
 					return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
 					});
@@ -214,9 +239,42 @@ namespace PepperDash.Essentials.DM

                        }
                    });
+
 				InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });

                OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Outputs[tempX].EndpointOnlineFeedback; });
+
+                InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => 
+                {
+                    var inputCard = Chassis.Inputs[tempX];
+
+                    if (inputCard.Card is DmcHd)
+                    {
+                        InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
+
+                        if ((inputCard.Card as DmcHd).HdmiInput.HdcpSupportOnFeedback.BoolValue)
+                            return 1;
+                        else
+                            return 0;
+                    }
+                    else if (inputCard.Card is DmcHdDsp)
+                    {
+                        InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
+
+                        if ((inputCard.Card as DmcHdDsp).HdmiInput.HdcpSupportOnFeedback.BoolValue)
+                            return 1;
+                        else
+                            return 0;
+                    }
+                    else if (inputCard.Card is Dmc4kHdBase)
+                    {
+                        InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
+
+                        return (int)(inputCard.Card as Dmc4kHdBase).HdmiInput.HdcpReceiveCapability;
+                    }
+                    else
+                        return 0;
+                });
 			}
 		}

@@ -308,38 +366,38 @@ namespace PepperDash.Essentials.DM
            else if (type == "dmcS")
            {
                new DmcS(number, Chassis);
-                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
                AddInCardHdmiAndAudioLoopPorts(number);
            }
            else if (type == "dmcSDsp")
            {
                new DmcSDsp(number, Chassis);
-                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
                AddInCardHdmiAndAudioLoopPorts(number);
            }
            else if (type == "dmcS2")
            {
                new DmcS2(number, Chassis);
-                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
                AddInCardHdmiAndAudioLoopPorts(number);
            }
            else if (type == "dmcS2Dsp")
            {
                new DmcS2Dsp(number, Chassis);
-                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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);
+                AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
+                AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi, null);
                AddInCardHdmiAndAudioLoopPorts(number);
            }
            else if (type == "dmcDvi")
            {
                new DmcDvi(number, Chassis);
-                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Dvi);
+                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Dvi);
                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
                AddInCardHdmiLoopPort(number);
            }
@@ -383,32 +441,32 @@ namespace PepperDash.Essentials.DM
            else if (type == "dmcStr")
            {
                new DmcStr(number, Chassis);
-                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
+                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
                AddInCardHdmiAndAudioLoopPorts(number);
            }
        }

        void AddDmInCardPorts(uint number)
        {
-            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
+            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
            AddInCardHdmiAndAudioLoopPorts(number);
        }

        void AddHdmiInCardPorts(uint number, ICec cecPort)
        {
-            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
+            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
        }

        void AddInCardHdmiLoopPort(uint number)
        {
-            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
        }

        /// <summary>
@@ -461,23 +519,23 @@ namespace PepperDash.Essentials.DM
            {
                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);
+                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(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);
+                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(number, "streamOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
            }

            else
@@ -486,17 +544,17 @@ namespace PepperDash.Essentials.DM

        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);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", 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);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 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.DmCat, 2 * (number - 1) + 2);
        }


@@ -530,9 +588,9 @@ namespace PepperDash.Essentials.DM
        /// <summary>
        /// Adds OutputPort
        /// </summary>
-        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
+        void AddOutputPortWithDebug(string cardName, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
        {
-            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+            var portKey = string.Format("{0}--{1}", cardName, portName);
            Debug.Console(2, this, "Adding output port '{0}'", portKey);
            OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
        }
@@ -540,9 +598,9 @@ namespace PepperDash.Essentials.DM
        /// <summary>
        /// Adds OutputPort and sets Port as ICec object
        /// </summary>
-        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
+        void AddOutputPortWithDebug(string cardName, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
        {
-            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+            var portKey = string.Format("outputCard{0}--{1}", cardName, portName);
            Debug.Console(2, this, "Adding output port '{0}'", portKey);
            var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);

@@ -566,35 +624,72 @@ namespace PepperDash.Essentials.DM
        //}


-		void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) {
+		void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) 
+        {
+            switch (args.EventId)
+            {
+                case DMSystemEventIds.SystemIdEventId:
+                    {
+                        Debug.Console(2, this, "SystemIdEvent Value: {0}", Chassis.SystemIdFeedback.UShortValue);
+                        SystemIdFeebdack.FireUpdate();
+                        break;
+                    }
+                case DMSystemEventIds.SystemIdBusyEventId:
+                    {
+                        Debug.Console(2, this, "SystemIdBusyEvent State: {0}", Chassis.SystemIdBusy.BoolValue);
+                        SystemIdBusyFeedback.FireUpdate();
+                        break;
+                    }
+            }
+		}

-			}
-		void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
-			//Debug.Console(2, this, "DMSwitch:{0} Input:{1} Event:{2}'", this.Name, args.Number, args.EventId.ToString());
+		void Chassis_DMInputChange(Switch device, DMInputEventArgs args)
+        {
 				
-			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;
-					}
+		    switch (args.EventId) {
+			    case DMInputEventIds.EndpointOnlineEventId: 
+                    {
+				        Debug.Console(2, this, "DM Input EndpointOnlineEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+				        InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+				        break;
+				    }
+                case DMInputEventIds.OnlineFeedbackEventId:
+                    {
+                        Debug.Console(2, this, "DM Input 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;
+				    }
+                case DMInputEventIds.UsbRoutedToEventId:
+                    {
+                        Debug.Console(2, this, "DM Input {0} UsbRoutedToEventId", args.Number);
+                        UsbInputRoutedToFeebacks[args.Number].FireUpdate();
+                        break;
+                    }
+                case DMInputEventIds.HdcpCapabilityFeedbackEventId:
+                    {
+                        Debug.Console(2, this, "DM Input {0} HdcpCapabilityFeedbackEventId", args.Number);
+                        InputCardHdcpCapabilityFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
                default:
                    {
                        Debug.Console(2, this, "DMInputChange fired for Input {0} with Unhandled EventId: {1}", args.Number, args.EventId);
                        break;
                    }
-				}
-			}
+		    }
+		}
        /// 
        /// </summary>
        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
@@ -613,13 +708,13 @@ namespace PepperDash.Essentials.DM
                        }
                        break;
                    }
-                case DMOutputEventIds.OnlineFeedbackEventId:
+                case DMOutputEventIds.EndpointOnlineEventId:
                {
-                    Debug.Console(2, this, "Output {0} DMOutputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                    Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
                    OutputEndpointOnlineFeedbacks[output].FireUpdate();
                    break;
                }
-                case DMInputEventIds.OnlineFeedbackEventId:
+                case DMOutputEventIds.OnlineFeedbackEventId:
                {
                    Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
                    OutputEndpointOnlineFeedbacks[output].FireUpdate();
@@ -660,6 +755,12 @@ namespace PepperDash.Essentials.DM
                    OutputNameFeedbacks[output].FireUpdate();
                    break;
                }
+                case DMOutputEventIds.UsbRoutedToEventId:
+                {
+                    Debug.Console(2, this, "DM Output {0} UsbRoutedToEventId", args.Number);
+                    UsbOutputRoutedToFeebacks[args.Number].FireUpdate();
+                    break;
+                }
                default:
                {
                    Debug.Console(2, this, "DMOutputChange fired for Output {0} with Unhandled EventId: {1}", args.Number, args.EventId);
@@ -690,7 +791,7 @@ namespace PepperDash.Essentials.DM
 			if (IsOnline.BoolValue)
 			{
                Chassis.EnableAudioBreakaway.BoolValue = true;
-                //Chassis.EnableUSBBreakaway.BoolValue = true;
+                Chassis.EnableUSBBreakaway.BoolValue = true;

 				if (InputNames != null)
 					foreach (var kvp in InputNames)
@@ -726,19 +827,34 @@ namespace PepperDash.Essentials.DM
 			}

 			Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
+            Card.DMOCard outCard = input == 0 ? null : Chassis.Outputs[output];

-			// NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
-			if (sigType != eRoutingSignalType.Audio)
+			// NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES 
+			if ((sigType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
 			{
 				Chassis.VideoEnter.BoolValue = true;
 				Chassis.Outputs[output].VideoOut = inCard;
 			}

-			if (sigType != eRoutingSignalType.Video)
+			if ((sigType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
 			{
 				Chassis.AudioEnter.BoolValue = true;
 				Chassis.Outputs[output].AudioOut = inCard;
 			}
+
+            if ((sigType | eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
+            {
+                Chassis.USBEnter.BoolValue = true;
+                if (Chassis.Outputs[output] != null)
+                    Chassis.Outputs[output].USBRoutedTo = inCard;
+            }
+
+            if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
+            {
+                Chassis.USBEnter.BoolValue = true;
+                if(Chassis.Inputs[input] != null)
+                    Chassis.Inputs[input].USBRoutedTo = outCard; 
+            }
 		}

 		#endregion
--- a/DM/Essentials_DM/Chassis/DmpsInternalVirtualDmTxController.cs
+++ b/DM/Essentials_DM/Chassis/DmpsInternalVirtualDmTxController.cs
@@ -92,7 +92,7 @@ namespace PepperDash.Essentials.DM
            {
                InputCard = inputCard as Card.Dmps3HdmiVgaInput;
            
-                HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi,
+                HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi,
                    eDmps3InputVideoSource.Hdmi, this, VideoStatusHelper.GetHdmiInputStatusFuncs(InputCard.HdmiInputPort));
                VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
                    eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eDmps3InputVideoSource.Vga, this,
@@ -140,7 +140,7 @@ namespace PepperDash.Essentials.DM
                };

                AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-                    eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, eDmps3InputVideoSource.Auto, this, combinedFuncs);
+                    eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, eDmps3InputVideoSource.Auto, this, combinedFuncs);

                ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput", () => ActualVideoInput.ToString());

@@ -164,7 +164,7 @@ namespace PepperDash.Essentials.DM
                // Set Ports for CEC
                HdmiIn.Port = InputCard.HdmiInputPort;

-                VirtualDmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+                VirtualDmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                    eRoutingPortConnectionType.None, null, this);

                AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
@@ -316,7 +316,7 @@ namespace PepperDash.Essentials.DM
        {
            InputCard = inputCard;

-            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi,
+            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi,
                eDmps3InputVideoSource.Hdmi, this, VideoStatusHelper.GetHdmiInputStatusFuncs(InputCard.HdmiInputPort));
            VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eDmps3InputVideoSource.Vga, this,
@@ -372,7 +372,7 @@ namespace PepperDash.Essentials.DM
            };

            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput", () => ActualVideoInput.ToString());

@@ -396,7 +396,7 @@ namespace PepperDash.Essentials.DM
            // Set Ports for CEC
            HdmiIn.Port = InputCard.HdmiInputPort;

-            VirtualDmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+            VirtualDmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.None, null, this);

            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
--- a/DM/Essentials_DM/Chassis/DmpsRoutingController.cs
+++ b/DM/Essentials_DM/Chassis/DmpsRoutingController.cs
@@ -259,7 +259,7 @@ namespace PepperDash.Essentials.DM

                var cecPort = hdmiInputCard.HdmiInputPort;

-                AddInputPortWithDebug(number, string.Format("HdmiIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);              
+                AddInputPortWithDebug(number, string.Format("HdmiIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, cecPort);              
            }
            else if (inputCard is Card.Dmps3HdmiInput)
            {
@@ -267,7 +267,7 @@ namespace PepperDash.Essentials.DM

                var cecPort = hdmiInputCard.HdmiInputPort;

-                AddInputPortWithDebug(number, string.Format("HdmiIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
+                AddInputPortWithDebug(number, string.Format("HdmiIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, cecPort);
                AddInputPortWithDebug(number, string.Format("HudioIn{1}", number), eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
            }
            else if (inputCard is Card.Dmps3HdmiVgaInput)
@@ -281,7 +281,7 @@ namespace PepperDash.Essentials.DM

                DeviceManager.AddDevice(inputCardController);

-                AddInputPortWithDebug(number, string.Format("HdmiVgaIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.BackplaneOnly);
+                AddInputPortWithDebug(number, string.Format("HdmiVgaIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.BackplaneOnly);
            }
            else if (inputCard is Card.Dmps3HdmiVgaBncInput)
            {
@@ -294,7 +294,7 @@ namespace PepperDash.Essentials.DM

                DeviceManager.AddDevice(inputCardController);

-                AddInputPortWithDebug(number, string.Format("HdmiVgaBncIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.BackplaneOnly);
+                AddInputPortWithDebug(number, string.Format("HdmiVgaBncIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.BackplaneOnly);

            }
            else if (inputCard is Card.Dmps3DmInput)
@@ -303,13 +303,13 @@ namespace PepperDash.Essentials.DM

                var cecPort = hdmiInputCard.DmInputPort;

-                AddInputPortWithDebug(number, string.Format("DmIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, cecPort);
+                AddInputPortWithDebug(number, string.Format("DmIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, cecPort);
            }
            else if (inputCard is Card.Dmps3AirMediaInput)
            {
                var airMediaInputCard = inputCard as Card.Dmps3AirMediaInput;

-                AddInputPortWithDebug(number, string.Format("AirMediaIn{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
+                AddInputPortWithDebug(number, string.Format("AirMediaIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
            }
        }

@@ -440,7 +440,7 @@ namespace PepperDash.Essentials.DM
        /// <param name="cecPort"></param>
        void AddHdmiOutputPort(uint number, ICec cecPort)
        {
-            AddOutputPortWithDebug(number, string.Format("hdmiOut{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, number, cecPort);
+            AddOutputPortWithDebug(number, string.Format("hdmiOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, number, cecPort);
        }

        /// <summary>
@@ -449,7 +449,7 @@ namespace PepperDash.Essentials.DM
        /// <param name="number"></param>
        void AddDmOutputPort(uint number)
        {
-            AddOutputPortWithDebug(number, string.Format("dmOut{0}", number), eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, number);
+            AddOutputPortWithDebug(number, string.Format("dmOut{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, number);
        }

        /// <summary>
@@ -611,25 +611,35 @@ namespace PepperDash.Essentials.DM
                    }

                    DMInput inCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput;
-
+                    Card.Dmps3OutputBase outCard = output == 0 ? null : Dmps.SwitcherOutputs[output] as Card.Dmps3OutputBase;

                    if (inCard != null)
                    {
-                        // NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
-                        if (sigType != eRoutingSignalType.Audio)
+                        // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES 
+                        if ((sigType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
                        {
-                            var outputCard = Dmps.SwitcherOutputs[output] as Card.Dmps3OutputBase;

                            //SystemControl.VideoEnter.BoolValue = true;
-                            if (outputCard != null && outputCard.VideoOut != null)
-                                outputCard.VideoOut = inCard;
+                            if (outCard != null && outCard.VideoOut != null)
+                                outCard.VideoOut = inCard;
                        }

-                        if (sigType != eRoutingSignalType.Video)
+                        if ((sigType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
                        {
-                            var outputCard = Dmps.SwitcherOutputs[output] as Card.Dmps3OutputBase;
-                            if (outputCard != null && outputCard.AudioOut != null)
-                                outputCard.AudioOut = inCard;
+                            if (outCard != null && outCard.AudioOut != null)
+                                outCard.AudioOut = inCard;
+                        }
+
+                        if ((sigType | eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
+                        {
+                            if (outCard != null && outCard.USBRoutedTo != null)
+                                outCard.USBRoutedTo = inCard;
+                        }
+
+                        if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
+                        {
+                            if (inCard != null && inCard.USBRoutedTo != null)
+                                inCard.USBRoutedTo = outCard;
                        }
                    }
                    else
--- a/DM/Essentials_DM/Chassis/HdMdNxM4kEController.cs
+++ b/DM/Essentials_DM/Chassis/HdMdNxM4kEController.cs
@@ -35,11 +35,11 @@ namespace PepperDash.Essentials.DM.Chassis
 			InputPorts = new RoutingPortCollection<RoutingInputPort>();
 			for (uint i = 1; i <= 4; i++)
 			{
-				InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.AudioVideo,
+				InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 					eRoutingPortConnectionType.Hdmi, i, this));
 			}
 			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
-			OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+			OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this));

 			// physical settings
--- a/DM/Essentials_DM/Endpoints/Receivers/DmHdBaseTEndpointController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmHdBaseTEndpointController.cs
@@ -32,9 +32,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HDBaseTSink = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HDBaseTSink = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            // Set Ports for CEC
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc100SController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc100SController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            // Set Ports for CEC
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc150SController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc150SController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc200CController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc200CController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
 			: base(key, name, rmc)
 		{
 			Rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc200S2Controller.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc200S2Controller.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc200SController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc200SController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
 			: base(key, name, rmc)
 		{
 			Rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs
@@ -42,9 +42,9 @@ namespace PepperDash.Essentials.DM
 			: base(key, name, rmc)
 		{
 			Rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
 			BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
 				eRoutingPortConnectionType.LineAudio, null, this);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc4k100C1GController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc4k100C1GController.cs
@@ -33,9 +33,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            // Set Ports for CEC
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc4kScalerCDspController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc4kScalerCDspController.cs
@@ -42,9 +42,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);
            BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
                eRoutingPortConnectionType.LineAudio, null, this);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerCController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerCController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
 			: base(key, name, rmc)
 		{
 			Rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerS2Controller.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerS2Controller.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerSController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerSController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
            : base(key, name, rmc)
        {
            Rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

            EdidManufacturerFeedback = new StringFeedback(() => Rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcX100CController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcX100CController.cs
@@ -41,9 +41,9 @@ namespace PepperDash.Essentials.DM
 			: base(key, name, rmc)
 		{
 			Rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);

            // Set Ports for CEC
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx200Controller.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx200Controller.cs
@@ -91,7 +91,7 @@ namespace PepperDash.Essentials.DM
            Tx = tx;

            HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
            VgaInput = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, DmTx200Base.eSourceSelection.Analog, this,
@@ -155,9 +155,9 @@ namespace PepperDash.Essentials.DM
            };

            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-    eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+    eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

-            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, null, this);
+            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);

            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx201CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx201CController.cs
@@ -92,7 +92,7 @@ namespace PepperDash.Essentials.DM
 			Tx = tx;

 			HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
-				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
+				eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
 				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
 			VgaInput = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
 				eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, DmTx200Base.eSourceSelection.Analog, this,
@@ -156,10 +156,10 @@ namespace PepperDash.Essentials.DM
 			};

 			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-	eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+	eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

-			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, null, this);
-			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);

            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx401CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx401CController.cs
@@ -92,10 +92,10 @@ namespace PepperDash.Essentials.DM
 			Tx = tx;

 			HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.HDMI, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.HDMI, this,
 				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
 			DisplayPortIn = new RoutingInputPortWithVideoStatuses(DmPortName.DisplayPortIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.DisplayPort, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.DisplayPort, this,
 				VideoStatusHelper.GetDisplayPortInputStatusFuncs(tx.DisplayPortInput));
 			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.VGA, this, 
@@ -169,7 +169,7 @@ namespace PepperDash.Essentials.DM
 			};


-            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, null, this);

            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k100Controller.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k100Controller.cs
@@ -67,9 +67,9 @@ namespace PepperDash.Essentials.DM
            Tx = tx;

            HdmiIn = new RoutingInputPort(DmPortName.HdmiIn1,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this);
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this);

-            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, null, this);

            // Set Ports for CEC
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k202CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k202CController.cs
@@ -82,10 +82,10 @@ namespace PepperDash.Essentials.DM
            Tx = tx;

            HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
            HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
                () => ActualActiveVideoInput.ToString());
@@ -151,11 +151,11 @@ namespace PepperDash.Essentials.DM
            };

            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

-            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, null, this);
-            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);


--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs
@@ -86,10 +86,10 @@ namespace PepperDash.Essentials.DM
 			Tx = tx;

 			HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
 				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
 			HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
 				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
 			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.Vga, this, 
@@ -161,11 +161,11 @@ namespace PepperDash.Essentials.DM
 			};

 			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+				eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

-			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, 
+			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.DmCat, null, this);
-			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);


--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz302CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz302CController.cs
@@ -86,13 +86,13 @@ namespace PepperDash.Essentials.DM
            Tx = tx;

            HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
            HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
            DisplayPortIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DisplayPort, eVst.DisplayPort, this,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DisplayPort, eVst.DisplayPort, this,
                VideoStatusHelper.GetDisplayPortInputStatusFuncs(tx.DisplayPortInput));
            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
                () => ActualActiveVideoInput.ToString());
@@ -161,11 +161,11 @@ namespace PepperDash.Essentials.DM
            };

            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);

-            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DmCat, null, this);
-            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);


@@ -207,27 +207,27 @@ namespace PepperDash.Essentials.DM
                {
                    case 0:
                        {
-                            ExecuteSwitch(eVst.Auto, null, eRoutingSignalType.AudioVideo);
+                            ExecuteSwitch(eVst.Auto, null, eRoutingSignalType.Audio | eRoutingSignalType.Video);
                            break;
                        }
                    case 1:
                        {
-                            ExecuteSwitch(HdmiIn1.Selector, null, eRoutingSignalType.AudioVideo);
+                            ExecuteSwitch(HdmiIn1.Selector, null, eRoutingSignalType.Audio | eRoutingSignalType.Video);
                            break;
                        }
                    case 2:
                        {
-                            ExecuteSwitch(HdmiIn2.Selector, null, eRoutingSignalType.AudioVideo);
+                            ExecuteSwitch(HdmiIn2.Selector, null, eRoutingSignalType.Audio | eRoutingSignalType.Video);
                            break;
                        }
                    case 3:
                        {
-                            ExecuteSwitch(DisplayPortIn.Selector, null, eRoutingSignalType.AudioVideo);
+                            ExecuteSwitch(DisplayPortIn.Selector, null, eRoutingSignalType.Audio | eRoutingSignalType.Video);
                            break;
                        }
                    case 4:
                        {
-                            ExecuteSwitch(eVst.AllDisabled, null, eRoutingSignalType.AudioVideo);
+                            ExecuteSwitch(eVst.AllDisabled, null, eRoutingSignalType.Audio | eRoutingSignalType.Video);
                            break;
                        }
                }
--- a/DM/Essentials_DM/Nvx/NvxDirectorController.cs
+++ b/DM/Essentials_DM/Nvx/NvxDirectorController.cs
@@ -326,38 +326,38 @@
 //            else if (type == "dmcS")
 //            {
 //                new DmcS(number, Chassis);
-//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
 //                AddInCardHdmiAndAudioLoopPorts(number);
 //            }
 //            else if (type == "dmcSDsp")
 //            {
 //                new DmcSDsp(number, Chassis);
-//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
 //                AddInCardHdmiAndAudioLoopPorts(number);
 //            }
 //            else if (type == "dmcS2")
 //            {
 //                new DmcS2(number, Chassis);
-//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
 //                AddInCardHdmiAndAudioLoopPorts(number);
 //            }
 //            else if (type == "dmcS2Dsp")
 //            {
 //                new DmcS2Dsp(number, Chassis);
-//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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);
+//                AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
+//                AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi, null);
 //                AddInCardHdmiAndAudioLoopPorts(number);
 //            }
 //            else if (type == "dmcDvi")
 //            {
 //                new DmcDvi(number, Chassis);
-//                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Dvi);
+//                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Dvi);
 //                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
 //                AddInCardHdmiLoopPort(number);
 //            }
@@ -401,32 +401,32 @@
 //            else if (type == "dmcStr")
 //            {
 //                new DmcStr(number, Chassis);
-//                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
+//                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
 //                AddInCardHdmiAndAudioLoopPorts(number);
 //            }
 //        }

 //        void AddDmInCardPorts(uint number)
 //        {
-//            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
+//            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
 //            AddInCardHdmiAndAudioLoopPorts(number);
 //        }

 //        void AddHdmiInCardPorts(uint number, ICec cecPort)
 //        {
-//            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
+//            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, cecPort);
 //            AddInCardHdmiAndAudioLoopPorts(number);
 //        }

 //        void AddInCardHdmiAndAudioLoopPorts(uint number)
 //        {
-//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
 //            AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
 //        }

 //        void AddInCardHdmiLoopPort(uint number)
 //        {
-//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
 //        }

 //        /// <summary>
@@ -479,23 +479,23 @@
 //            {
 //                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);
+//                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+//                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//                AddOutputPortWithDebug(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(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);
+//                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+//                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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);
+//                AddOutputPortWithDebug(number, "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
 //            }

 //            else
@@ -504,17 +504,17 @@

 //        void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
 //        {
-//            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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, "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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);
+//            AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+//            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//            AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
 //        }


--- a/Common/DiscPlayer/IRDiscPlayerBase.cs
+++ b/Common/DiscPlayer/IRDiscPlayerBase.cs
@@ -33,7 +33,7 @@ namespace PepperDash.Essentials.Devices.Common

 			PowerIsOnFeedback = new BoolFeedback(() => _PowerIsOn);

-			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
 			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio, 
 				eRoutingPortConnectionType.DigitalAudio, null, this);
--- a/Common/Display/AvocorVTFDisplay.cs
+++ b/Common/Display/AvocorVTFDisplay.cs
@@ -146,28 +146,28 @@ namespace PepperDash.Essentials.Devices.Displays
                v => SetVolume((ushort)v), 
                () => _LastVolumeSent);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this), InputHdmi1Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this), InputHdmi2Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this), InputHdmi3Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi4), this), InputHdmi4Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn5, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn5, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi5), this), InputHdmi5Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort1), this), InputDisplayPort1Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Dvi, new Action(InputVga1), this), InputVga1Value);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.IpcOps, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.IpcOps, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Composite, new Action(InputIpcOps), this), InputIpcOpsValue);

 			AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.MediaPlayer, eRoutingSignalType.Video,
--- a/Common/Display/NECPSXMDisplay.cs
+++ b/Common/Display/NECPSXMDisplay.cs
@@ -103,21 +103,21 @@ namespace PepperDash.Essentials.Devices.Displays
 			PortGather.LineReceived += this.Port_LineReceived;
 			CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000, "xx\x0d");

-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, 
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi4), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort1), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn2, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort2), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Dvi, new Action(InputDvi1), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Composite, new Action(InputVideo1), this));
 			InputPorts.Add(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
                eRoutingPortConnectionType.Vga, new Action(InputVga), this));
--- a/Common/Display/PanasonicThDisplay.cs
+++ b/Common/Display/PanasonicThDisplay.cs
@@ -103,14 +103,14 @@ namespace PepperDash.Essentials.Devices.Displays
 			PortGather.LineReceived += this.Port_LineReceived;
 			CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000, "\x02QPW\x03"); // Query Power

-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, 
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this));

-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Dvi, new Action(InputDvi1), this));
-			InputPorts.Add(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.AudioVideo,
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Composite, new Action(InputVideo1), this));
 			InputPorts.Add(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
                eRoutingPortConnectionType.Vga, new Action(InputVga), this));
--- a/Common/Display/SamsungMDCDisplay.cs
+++ b/Common/Display/SamsungMDCDisplay.cs
@@ -98,28 +98,28 @@ namespace PepperDash.Essentials.Devices.Displays
                v => SetVolume((ushort)v), 
                () => _LastVolumeSent);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this), 0x21);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1PC, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn1PC, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1PC), this), 0x22);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this), 0x23);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2PC, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn2PC, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2PC), this), 0x24);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this), 0x32);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort1), this), 0x25);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Dvi, new Action(InputDvi1), this), 0x18);

-            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.AudioVideo,
+            AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Composite, new Action(InputVideo1), this), 0x08);

 			AddRoutingInputPort(new RoutingInputPort(RoutingPortNames.RgbIn1, eRoutingSignalType.Video,
--- a/Common/Generic/GenericSource.cs
+++ b/Common/Generic/GenericSource.cs
@@ -21,7 +21,7 @@ namespace PepperDash.Essentials.Devices.Common
 			: base(key, name)
 		{

-            AnyOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.AudioVideo, 
+            AnyOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
 			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { AnyOut };
 		}
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -36,7 +36,7 @@ namespace PepperDash.Essentials.Devices.Common
 			HasPowerOnFeedback = new BoolFeedback("HasPowerFeedback", 
 				() => this.GetVideoStatuses() != VideoStatusOutputs.NoStatus);
 			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
-			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.AudioVideo, 
+			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.None, 0, this));
 		}

--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -36,7 +36,7 @@ namespace PepperDash.Essentials.Devices.Common
 			HasPowerOnFeedback = new BoolFeedback("HasPowerFeedback", 
 				() => this.GetVideoStatuses() != VideoStatusOutputs.NoStatus);
 			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
-			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.AudioVideo, 
+			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.None, 0, this));
 		}

--- a/Common/SetTopBox/IRSetTopBoxBase.cs
+++ b/Common/SetTopBox/IRSetTopBoxBase.cs
@@ -46,7 +46,7 @@ namespace PepperDash.Essentials.Devices.Common
 			KeypadAccessoryButton2Command = "NumericEnter";
 			KeypadAccessoryButton2Label = "Enter";

-			AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.AudioVideo,
+			AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
 				eRoutingPortConnectionType.Hdmi, null, this);
 			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio,
 				eRoutingPortConnectionType.DigitalAudio, null, this);
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -25,7 +25,7 @@ namespace PepperDash.Essentials.Devices.Common
 			IrPort = portCont;
 			DeviceManager.AddDevice(portCont);

-			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
 			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio, 
 				eRoutingPortConnectionType.DigitalAudio, null, this);
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -26,7 +26,7 @@ namespace PepperDash.Essentials.Devices.Common
 			IrPort = portCont;
 			DeviceManager.AddDevice(portCont);;

-			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
 			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut };
 		}
--- a/Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs
+++ b/Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs
@@ -360,16 +360,16 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
            CodecStatus.Status.Conference.Presentation.Mode.ValueChangedAction += SharingContentIsOnFeedback.FireUpdate;
            CodecStatus.Status.Conference.Presentation.Mode.ValueChangedAction += FarEndIsSharingContentFeedback.FireUpdate;

-			CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.AudioVideo, 
+			CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, new Action(StopSharing), this);
-			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, 
+			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource1), this);
-			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo, 
+			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, new Action(SelectPresentationSource2), this);

-			HdmiOut1 = new RoutingOutputPort(RoutingPortNames.HdmiOut1, eRoutingSignalType.AudioVideo, 
+			HdmiOut1 = new RoutingOutputPort(RoutingPortNames.HdmiOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
 				eRoutingPortConnectionType.Hdmi, null, this);
-            HdmiOut2 = new RoutingOutputPort(RoutingPortNames.HdmiOut2, eRoutingSignalType.AudioVideo,
+            HdmiOut2 = new RoutingOutputPort(RoutingPortNames.HdmiOut2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);

 			InputPorts.Add(CodecOsdIn);
--- a/Common/VideoCodec/MockVC/MockVC.cs
+++ b/Common/VideoCodec/MockVC/MockVC.cs
@@ -56,13 +56,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec

            CurrentDirectoryResultIsNotDirectoryRoot.FireUpdate();

-            CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 0, this);
+            CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 0, this);
            InputPorts.Add(CodecOsdIn);
-            HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 1, this);
+            HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 1, this);
            InputPorts.Add(HdmiIn1);
-            HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2, this);
+            HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2, this);
            InputPorts.Add(HdmiIn2);
-            HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null, this);
+            HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null, this);
            OutputPorts.Add(HdmiOut);

            CallHistory = new CodecCallHistory();
--- a/Common/VideoCodec/ZoomRoom/ZoomRoom.cs
+++ b/Common/VideoCodec/ZoomRoom/ZoomRoom.cs
@@ -201,10 +201,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
            PortGather.IncludeDelimiter = true;
            PortGather.LineReceived += this.Port_LineReceived;

-            CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.AudioVideo,
+            CodecOsdIn = new RoutingInputPort(RoutingPortNames.CodecOsd, eRoutingSignalType.Audio | eRoutingSignalType.Video,
            eRoutingPortConnectionType.Hdmi, new Action(StopSharing), this);
 
-            Output1 = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.AudioVideo,
+            Output1 = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                eRoutingPortConnectionType.Hdmi, null, this);
 
            SelfviewIsOnFeedback = new BoolFeedback(SelfViewIsOnFeedbackFunc);
Author	SHA1	Message	Date
Neil Dorin	d93a563cd8	Merged in feature/ecs-1140 (pull request #28 ) Feature/ecs 1140 Approved-by: Neil Dorin <ndorin@pepperdash.com>	2019-08-16 05:29:06 +00:00
Neil Dorin	63f81456e8	Merge branch 'feature/ecs-1139' into feature/ecs-1140 # Conflicts: # PepperDashEssentials/Bridges/DmChassisControllerBridge.cs # essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs	2019-08-15 21:07:16 -06:00
Neil Dorin	764d8d2b48	Tested working with USB routing and SystemId setting on DmChassisController and DmChassisControllerBridge	2019-08-15 20:56:03 -06:00
Neil Dorin	1ae6069ac2	Adds USB routing to DmChassisController and DmChassisControllerBridge. Major update to remove eRoutingSignalType.AudioVideo in favor of bitmasked values and adding UsbOutput and UsbInput types. Updated all affected routing ports and ExecuteSwitch method calls. Need to review and test routing to ensure bitwise operators are all correct.	2019-08-15 14:07:10 -06:00
Neil Dorin	7eccc82541	Adds HDCP Capability type values	2019-08-14 17:16:17 -06:00
Neil Dorin	b2dbd3c377	Built HDCP Capability feedbacks for input card HDMI ports	2019-08-14 16:48:15 -06:00
Neil Dorin	47e47ec272	Merged in bugfix/ecs-1138a (pull request #27 ) Minor correction to EventId	2019-08-14 20:13:32 +00:00
Neil Dorin	c392ac6b06	Minor correction to EventId	2019-08-14 14:13:00 -06:00
Neil Dorin	af2fe7e54e	Merged in bugfix/ecs-1138a (pull request #26 ) Fixed EventIds for EndpointOnlineFeedback in DMInput/Output change handlers Approved-by: Neil Dorin <ndorin@pepperdash.com>	2019-08-14 20:11:27 +00:00
Neil Dorin	3f68a84fe8	Fixed EventIds for EndpointOnlineFeedback in DMInput/Output change handlers	2019-08-14 14:09:11 -06:00
Neil Dorin	5d93a5177c	Start adding HDCP state feedback collection	2019-08-14 13:46:28 -06:00
Neil Dorin	f83a7aecf2	Updates eventIds for EndpointOnlineFeedabck	2019-08-14 13:29:04 -06:00
Neil Dorin	6b21b37aef	First attempt to address HDCP setting on input cards/TXs on DmChassisControllerBridge	2019-08-13 21:40:22 -06:00