Merge pull request #41 from bitm0de/master

Output Disabled By Hdcp Implementation (Feedback)

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -1,4 +1,5 @@
-using System;
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -16,7 +17,7 @@ using Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Bridges
 {
-    public static class DmChassisControllerApiExtensions
+    public static class DmChassisControllerApiExtentions
     {
         public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
         {
@@ -81,14 +82,14 @@ namespace PepperDash.Essentials.Bridges
                         }
                     }
 
-                    if (advancedTxDevice != null)   // Advanced TX device
+                    if (basicTxDevice != null && advancedTxDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+                    if (advancedTxDevice != null)
                     {
                         advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
-
-                        // Flag if the TX is an advanced endpoint type
-                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
                     }
-                    else if(advancedTxDevice == null || basicTxDevice != null)  // Basic TX device
+                    else if(advancedTxDevice == null || basicTxDevice != null)
                     {
                         Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
                         dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
@@ -167,6 +168,7 @@ namespace PepperDash.Essentials.Bridges
                         }
                     }
                 }
+                
                 if (dmChassis.RxDictionary.ContainsKey(ioSlot))
                 {
                     Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
@@ -191,11 +193,12 @@ namespace PepperDash.Essentials.Bridges
                 dmChassis.UsbOutputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputUsb + ioSlot]);
                 dmChassis.UsbInputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.InputUsb + ioSlot]);
 
-
                 dmChassis.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
                 dmChassis.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
                 dmChassis.OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames + ioSlot]);
                 dmChassis.OutputAudioRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentAudioInputNames + ioSlot]);
+                
+                dmChassis.OutputDisabledByHdcpFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputDisabledByHdcp + ioSlot]);
             }
         }
 
@@ -281,4 +284,5 @@ namespace PepperDash.Essentials.Bridges
         }
 
     }
+
 }

PepperDashEssentials/Bridges/JoinMaps/DmChassisControllerJoinMap.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -38,6 +38,10 @@ namespace PepperDash.Essentials.Bridges
         /// Range reports high if corresponding input's transmitter supports bridging as a separate device for detailed AV switching, HDCP control, etc.
         /// </summary>
         public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+        /// <summary>
+        /// Range reports high if corresponding output is disabled by HDCP.
+        /// </summary>
+        public uint OutputDisabledByHdcp { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
 #endregion
 
 #region Analogs
@@ -101,6 +105,7 @@ namespace PepperDash.Essentials.Bridges
             InputEndpointOnline = 500; //501-699
             OutputEndpointOnline = 700; //701-899
             TxAdvancedIsPresent = 1000; //1001-1199
+            OutputDisabledByHdcp = 1200; //1201-1399
 
             //Analog
             OutputVideo = 100; //101-299
@@ -139,6 +144,7 @@ namespace PepperDash.Essentials.Bridges
             OutputEndpointOnline = OutputEndpointOnline + joinOffset;
             HdcpSupportState = HdcpSupportState + joinOffset;
             HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+            OutputDisabledByHdcp = OutputDisabledByHdcp + joinOffset;
             TxAdvancedIsPresent = TxAdvancedIsPresent + joinOffset;
         }
     }

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs

@@ -1,18 +1,11 @@
-using System;
+
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Cards;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
-
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.DM.Cards;
-
 using PepperDash.Essentials.DM.Config;
 
 namespace PepperDash.Essentials.DM
@@ -39,16 +32,15 @@ namespace PepperDash.Essentials.DM
         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 Dictionary<uint, BoolFeedback> OutputDisabledByHdcpFeedbacks { 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
         public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
         public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
@@ -83,37 +75,56 @@ namespace PepperDash.Essentials.DM
                 uint ipid = properties.Control.IpIdInt;
 
                 DmMDMnxn chassis = null;
-				if (type == "dmmd8x8") { chassis = new DmMd8x8(ipid, Global.ControlSystem); }
+                switch (type) {
-				else if (type == "dmmd8x8rps") { chassis = new DmMd8x8rps(ipid, Global.ControlSystem); }
+                    case "dmmd8x8":
-				else if (type == "dmmd8x8cpu3") { chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8(ipid, Global.ControlSystem);
-				else if (type == "dmmd8x8cpu3rps") { chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem); }
+                        break;
-
+                    case "dmmd8x8rps":
-				else if (type == "dmmd16x16") { chassis = new DmMd16x16(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8rps(ipid, Global.ControlSystem);
-				else if (type == "dmmd16x16rps") { chassis = new DmMd16x16rps(ipid, Global.ControlSystem); }
+                        break;
-				else if (type == "dmmd16x16cpu3") { chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem); }
+                    case "dmmd8x8cpu3":
-				else if (type == "dmmd16x16cpu3rps") { chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem);
-
+                        break;
-				else if (type == "dmmd32x32") { chassis = new DmMd32x32(ipid, Global.ControlSystem); }
+                    case "dmmd8x8cpu3rps":
-				else if (type == "dmmd32x32rps") { chassis = new DmMd32x32rps(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem);
-				else if (type == "dmmd32x32cpu3") { chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem); }
+                        break;
-				else if (type == "dmmd32x32cpu3rps") { chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem); }
+                    case "dmmd16x16":
+                        chassis = new DmMd16x16(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16rps":
+                        chassis = new DmMd16x16rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16cpu3":
+                        chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16cpu3rps":
+                        chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32":
+                        chassis = new DmMd32x32(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32rps":
+                        chassis = new DmMd32x32rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32cpu3":
+                        chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32cpu3rps":
+                        chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem);
+                        break;
+                }
 
                 if (chassis == null)
-                {
                     return null;
-                }
 
                 var controller = new DmChassisController(key, name, chassis);
 
                 // add the cards and port names
                 foreach (var kvp in properties.InputSlots)
-                {
                     controller.AddInputCard(kvp.Value, kvp.Key);
-                }
+                
                 foreach (var kvp in properties.OutputSlots)
-				{
                     controller.AddOutputCard(kvp.Value, kvp.Key);
-				}
 
                 foreach (var kvp in properties.VolumeControls)
                 {
@@ -130,6 +141,7 @@ namespace PepperDash.Essentials.DM
                         audio = (card as Dmc4kHdo).Audio;
                     if (audio == null)
                         continue;
+
                     // wire up the audio to something here...
                     controller.AddVolumeControl(outNum, audio);
                 }
@@ -143,19 +155,21 @@ namespace PepperDash.Essentials.DM
                     Debug.Console(1, controller, "Setting No Route Text value to: {0}", controller.NoRouteText);
                 }
                 else
+                {
                     Debug.Console(1, controller, "NoRouteText not specified.  Defaulting to blank string.", controller.NoRouteText);
+                }
 
                 controller.PropertiesConfig = properties;
                 return controller;
             }
-			catch (System.Exception e)
+            catch (Exception e)
             {
                 Debug.Console(0, "Error creating DM chassis:\r{0}", e);
             }
+
             return null;
         }
 
-
         /// <summary>
         /// 
         /// </summary>
@@ -179,6 +193,7 @@ namespace PepperDash.Essentials.DM
             AudioOutputFeedbacks = new Dictionary<uint, IntFeedback>();
             UsbOutputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
             UsbInputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
+            OutputDisabledByHdcpFeedbacks = new Dictionary<uint, BoolFeedback>();
             VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
             InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
             OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
@@ -191,211 +206,170 @@ namespace PepperDash.Essentials.DM
             SystemIdBusyFeedback = new BoolFeedback(() => { return (Chassis as DmMDMnxn).SystemIdBusy.BoolValue; });
             InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
             InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
-		}
 
-        public override bool CustomActivate()
-        {
-            Debug.Console(2, this, "Setting up feedbacks.");
-
-            // Setup Output Card Feedbacks
             for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
             {
                 var tempX = x;
 
-                Debug.Console(2, this, "Setting up feedbacks for output slot: {0}", tempX);
-
                 if (Chassis.Outputs[tempX] != null)
                 {
-                    VideoOutputFeedbacks[tempX] = new IntFeedback(() =>
+                    VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
-                    {
-                        if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number; }
-                        else { return 0; };
-                    });
-                    AudioOutputFeedbacks[tempX] = new IntFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; }
-                        else { return 0; };
-                    });
-                    UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number; }
-                        else { return 0; };
-                    });
-
-                    OutputNameFeedbacks[tempX] = new StringFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].NameFeedback != null)
-                        {
-                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
-                        }
-                        else
-                        {
-                            return "";
-                        }
-                    });
-                    OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() =>
-                    {
                         if (Chassis.Outputs[tempX].VideoOutFeedback != null)
-                        {
+                            return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;
-                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+
-                        }
+                        return 0;
-                        else
-                        {
-                            return NoRouteText;
-                        }
                     });
-                    OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
+                    AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
-                    {
                         if (Chassis.Outputs[tempX].AudioOutFeedback != null)
-                        {
+                            return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number;
-                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
+
-                        }
+                        return 0;
-                        else
+                    });
-                        {
+                    UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Outputs[tempX].USBRoutedToFeedback != null)
+                            return (ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number;
+
+                        return 0;
+                    });
+
+                    OutputNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].NameFeedback != null)
+                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
+
+                        return "";
+                    });
+                    OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].VideoOutFeedback != null)
+                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+
                         return NoRouteText;
-
-                        }
                     });
+                    OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].AudioOutFeedback != null)
+                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
 
-                    OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
+                        return NoRouteText;
-                    {
+                    });
-                        return Chassis.Outputs[tempX].EndpointOnlineFeedback;
+                    OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => Chassis.Outputs[tempX].EndpointOnlineFeedback);
+                    
+                    OutputDisabledByHdcpFeedbacks[tempX] = new BoolFeedback(() => {
+                        var output = Chassis.Outputs[tempX];
+
+                        var hdmiTxOutput = output as Card.HdmiTx;
+                        if (hdmiTxOutput != null)
+                            return hdmiTxOutput.HdmiOutput.DisabledByHdcp.BoolValue;
+
+                        var dmHdmiOutput = output as Card.DmHdmiOutput;
+                        if (dmHdmiOutput != null)
+                            return dmHdmiOutput.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmsDmOutAdvanced = output as Card.DmsDmOutAdvanced;
+                        if (dmsDmOutAdvanced != null)
+                            return dmsDmOutAdvanced.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiAudioOutput = output as Card.Dmps3HdmiAudioOutput;
+                        if (dmps3HdmiAudioOutput != null)
+                            return dmps3HdmiAudioOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiOutput = output as Card.Dmps3HdmiOutput;
+                        if (dmps3HdmiOutput != null)
+                            return dmps3HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiOutputBackend = output as Card.Dmps3HdmiOutputBackend;
+                        if (dmps3HdmiOutputBackend != null)
+                            return dmps3HdmiOutputBackend.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        // var hdRx4kX10HdmiOutput = output as HdRx4kX10HdmiOutput;
+                        // if (hdRx4kX10HdmiOutput != null)
+                        //     return hdRx4kX10HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        // var hdMdNxMHdmiOutput = output as HdMdNxMHdmiOutput;
+                        // if (hdMdNxMHdmiOutput != null)
+                        //     return hdMdNxMHdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        return false;
                     });
                 }
-                else
-                {
-                    Debug.Console(2, this, "No Output Card defined in slot: {0}", tempX);
-                }
-            };
-
-            // Setup Input Card Feedbacks
-            for (uint x = 1; x <= Chassis.NumberOfInputs; x++)
-            {
-                var tempX = x;
-
-                Debug.Console(2, this, "Setting up feedbacks for input slot: {0}", tempX);
-
-                CheckForHdcp2Property(tempX);
 
                 if (Chassis.Inputs[tempX] != null)
                 {
+                    UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Inputs[tempX].USBRoutedToFeedback != null)
+                            return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number;
 
-                    UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() =>
+                        return 0;
-                    {
-                        if (Chassis.Inputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number; }
-                        else { return 0; };
                     });
-                    VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() =>
+                    VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
-                    {
                         if (Chassis.Inputs[tempX].VideoDetectedFeedback != null)
                             return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
-                        else
+                        
                         return false;
                     });
-                    InputNameFeedbacks[tempX] = new StringFeedback(() =>
+                    InputNameFeedbacks[tempX] = new StringFeedback(() => {
-                    {
                         if (Chassis.Inputs[tempX].NameFeedback != null)
-                        {
                             return Chassis.Inputs[tempX].NameFeedback.StringValue;
-                        }
+
-                        else
-                        {
                         return "";
-                        }
                     });
 
-                    InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
+                    InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
-                    {
-                        return Chassis.Inputs[tempX].EndpointOnlineFeedback;
-                    });
 
-                    InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() =>
+                    InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => {
-                    {
                         var inputCard = Chassis.Inputs[tempX];
 
-                        Debug.Console(2, this, "Adding InputCardHdcpCapabilityFeedback for slot: {0}", inputCard);
-
                         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)
+
+                        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)
+                        if (inputCard.Card is Dmc4kHdBase)
                         {
                             InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
-
                             return (int)(inputCard.Card as Dmc4kHdBase).HdmiInput.HdcpReceiveCapability;
                         }
-                        else if (inputCard.Card is Dmc4kCBase)
+                        if (inputCard.Card is Dmc4kCBase)
                         {
                             if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
                             {
                                 InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
-
                                 return (int)(inputCard.Card as Dmc4kCBase).DmInput.HdcpReceiveCapability;
                             }
-                            else if ((inputCard.Card as Dmc4kCBase).DmInput.HdcpSupportOnFeedback.BoolValue)
+
+                            if ((inputCard.Card as Dmc4kCBase).DmInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
                             return 0;
                         }
-                        else if (inputCard.Card is Dmc4kCDspBase)
+                        if (inputCard.Card is Dmc4kCDspBase)
                         {
                             if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
                             {
                                 InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
-
                                 return (int)(inputCard.Card as Dmc4kCDspBase).DmInput.HdcpReceiveCapability;
                             }
-                            else if ((inputCard.Card as Dmc4kCDspBase).DmInput.HdcpSupportOnFeedback.BoolValue)
+
+                            if ((inputCard.Card as Dmc4kCDspBase).DmInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
+                            
                             return 0;
                         }
-                        else
                         return 0;
                     });
                 }
-                else
-                {
-                    Debug.Console(2, this, "No Input Card defined in slot: {0}", tempX);
             }
         }
 
-            return base.CustomActivate();
-        }
-
-        /// <summary>
-        /// Checks for presence of config property defining if the input card supports HDCP2.
-        /// If not found, assumes false.
-        /// </summary>
-        /// <param name="inputSlot">Input Slot</param>
-        void CheckForHdcp2Property(uint inputSlot)
-        {
-            if (!PropertiesConfig.InputSlotSupportsHdcp2.ContainsKey(inputSlot))
-            {
-                Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
-@"Properties Config does not define inputSlotSupportsHdcp2 entry for input card: {0}.  Assuming false.  
-If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", inputSlot);
-                PropertiesConfig.InputSlotSupportsHdcp2.Add(inputSlot, false);
-            }
-            else
-                Debug.Console(2, this, "inputSlotSupportsHdcp2 for input card: {0} = {1}", inputSlot, PropertiesConfig.InputSlotSupportsHdcp2[inputSlot]);
-        }
-
         /// <summary>
         /// 
         /// </summary>
@@ -517,7 +491,8 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             {
                 new DmcSdi(number, Chassis);
                 AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
-                AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi, null);
+                AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Sdi, null);
                 AddInCardHdmiAndAudioLoopPorts(number);
             }
             else if (type == "dmcdvi")
@@ -577,6 +552,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
             AddInCardHdmiAndAudioLoopPorts(number);
         }
+
         void AddDmInCardPorts(uint number, ICec cecPort)
         {
             AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, cecPort);
@@ -591,13 +567,15 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void AddInCardHdmiAndAudioLoopPorts(uint number)
         {
-            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, 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(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null);
         }
 
         /// <summary>
@@ -617,13 +595,6 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 var cecPort2 = outputCard.Card2.HdmiOutput;
                 AddDmcHdoPorts(number, cecPort1, cecPort2);
             }
-            else if (type == "dmc4kzhdo")
-            {
-                var outputCard = new Dmc4kzHdoSingle(number, Chassis);
-                var cecPort1 = outputCard.Card1.HdmiOutput;
-                var cecPort2 = outputCard.Card2.HdmiOutput;
-                AddDmcHdoPorts(number, cecPort1, cecPort2);
-            }
             else if (type == "dmchdo")
             {
                 var outputCard = new DmcHdoSingle(number, Chassis);
@@ -659,23 +630,29 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             {
                 var outputCard = new DmcSoHdSingle(number, Chassis);
                 var cecPort1 = outputCard.Card1.HdmiOutput;
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                    eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 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), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
             }
             else if (type == "dmcs2ohd")
             {
                 var outputCard = new DmcS2oHdSingle(number, Chassis);
                 var cecPort1 = outputCard.Card1.HdmiOutput;
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                    eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 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), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
             }
             else if (type == "dmcstro")
             {
                 var outputCard = new DmcStroSingle(number, Chassis);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
             }
 
             else
@@ -684,20 +661,26 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
         {
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+                eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
+                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(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 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), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
         }
 
-
         /// <summary>
         /// Adds InputPort
         /// </summary>
@@ -719,16 +702,11 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             Debug.Console(2, this, "Adding input port '{0}'", portKey);
             var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
 
-            if (inputPort != null)
-            {
             if (cecPort != null)
                 inputPort.Port = cecPort;
 
             InputPorts.Add(inputPort);
         }
-            else
-                Debug.Console(2, this, "inputPort is null");
-        }
 
         /// <summary>
         /// Adds OutputPort
@@ -768,7 +746,6 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         //}
 
-
         void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args)
         {
             switch (args.EventId)
@@ -790,8 +767,8 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void Chassis_DMInputChange(Switch device, DMInputEventArgs args)
         {
-				
+            switch (args.EventId)
-		    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);
@@ -819,7 +796,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 case DMInputEventIds.UsbRoutedToEventId:
                 {
                     Debug.Console(2, this, "DM Input {0} UsbRoutedToEventId", args.Number);
-                        if(UsbInputRoutedToFeebacks[args.Number] != null)
+                    if (UsbInputRoutedToFeebacks[args.Number] != null)
                         UsbInputRoutedToFeebacks[args.Number].FireUpdate();
                     else
                         Debug.Console(1, this, "No index of {0} found in UsbInputRoutedToFeedbacks");
@@ -841,6 +818,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 }
             }
         }
+
         /// 
         /// </summary>
         void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
@@ -855,51 +833,47 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     {
                         VolumeControls[args.Number].VolumeEventFromChassis();
                     }
+
                     break;
                 }
                 case DMOutputEventIds.EndpointOnlineEventId:
                 {
-                    Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId 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 DMOutputEventIds.OnlineFeedbackEventId:
                 {
-                    Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                    Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number,
+                        Chassis.Outputs[output].EndpointOnlineFeedback);
                     OutputEndpointOnlineFeedbacks[output].FireUpdate();
                     break;
                 }
                 case DMOutputEventIds.VideoOutEventId:
                 {
                     if (Chassis.Outputs[output].VideoOutFeedback != null)
-                    {
                         Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
-                    }
+
                     if (VideoOutputFeedbacks.ContainsKey(output))
-                    {
                         VideoOutputFeedbacks[output].FireUpdate();
 
-                    }
                     if (OutputVideoRouteNameFeedbacks.ContainsKey(output))
-                    {
                         OutputVideoRouteNameFeedbacks[output].FireUpdate();
-                    }
+
                     break;
                 }
                 case DMOutputEventIds.AudioOutEventId:
                 {
                     if (Chassis.Outputs[output].AudioOutFeedback != null)
-                    {
                         Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
-                    }
+
                     if (AudioOutputFeedbacks.ContainsKey(output))
-                    {
                         AudioOutputFeedbacks[output].FireUpdate();
-                    }
+
                     if (OutputAudioRouteNameFeedbacks.ContainsKey(output))
-                    {
                         OutputAudioRouteNameFeedbacks[output].FireUpdate();
-                    }
+
                     break;
                 }
                 case DMOutputEventIds.OutputNameEventId:
@@ -914,13 +888,18 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     UsbOutputRoutedToFeebacks[args.Number].FireUpdate();
                     break;
                 }
+                case DMOutputEventIds.DisabledByHdcpEventId:
+                {
+                    Debug.Console(2, this, "DM Output {0} DisabledByHdcpEventId", args.Number);
+                    OutputDisabledByHdcpFeedbacks[args.Number].FireUpdate();
+                    break;
+                }
                 default:
                 {
                     Debug.Console(2, this, "DMOutputChange fired for Output {0} with Unhandled EventId: {1}", args.Number, args.EventId);
                     break;
                 }
             }
-
         }
 
         /// <summary>
@@ -931,13 +910,9 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
         {
             if (RouteOffTimers.ContainsKey(pnt))
                 return;
-			RouteOffTimers[pnt] = new CTimer(o =>
+            RouteOffTimers[pnt] = new CTimer(o => { ExecuteSwitch(0, pnt.Number, pnt.Type); }, RouteOffTime);
-			{
-				ExecuteSwitch(0, pnt.Number, pnt.Type);
-			}, RouteOffTime);
         }
 
-
         // Send out sigs when coming online
         void IsOnline_OutputChange(object sender, EventArgs e)
         {
@@ -950,19 +925,19 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     foreach (var kvp in InputNames)
                         Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
                 if (OutputNames != null)
-					foreach(var kvp in OutputNames)
+                    foreach (var kvp in OutputNames)
                         Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
             }
         }
 
         #region IRouting Members
-
         public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
         {
             Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
 
             var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
             var output = Convert.ToUInt32(outputSelector);
+
             // Check to see if there's an off timer waiting on this and if so, cancel
             var key = new PortNumberType(output, sigType);
             if (input == 0)
@@ -971,7 +946,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             }
             else
             {
-				if(RouteOffTimers.ContainsKey(key))
+                if (RouteOffTimers.ContainsKey(key))
                 {
                     Debug.Console(2, this, "{0} cancelling route off due to new source", output);
                     RouteOffTimers[key].Stop();
@@ -1005,11 +980,10 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
             {
                 Chassis.USBEnter.BoolValue = true;
-                if(Chassis.Inputs[input] != null)
+                if (Chassis.Inputs[input] != null)
                     Chassis.Inputs[input].USBRoutedTo = outCard;
             }
         }
-
         #endregion
     }
 
@@ -1018,10 +992,12 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
         public uint Number { get; private set; }
         public eRoutingSignalType Type { get; private set; }
 
-		public PortNumberType(uint number, eRoutingSignalType type) : this()
+        public PortNumberType(uint number, eRoutingSignalType type)
+            : this()
         {
             Number = number;
             Type = type;
         }
     }
+
 }