Combining repos

2026-02-08 09:15:06 +00:00 · 2017-03-21 08:36:26 -06:00
parent e196ad0419
commit b5444e3544
358 changed files with 17256 additions and 10215 deletions
--- a/DM/Essentials_DM.sln
+++ b/DM/Essentials_DM.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials_DM", "Essentials_DM\Essentials_DM.csproj", "{9199CE8A-0C9F-4952-8672-3EED798B284F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
--- a/REMOVE/DmInputCardBase.cs
+++ b/REMOVE/DmInputCardBase.cs
@@ -0,0 +1,62 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class DmInputCardControllerBase : IRoutingInputsOutputs
+//    {
+//        public string Key { get; private set; }
+//        public uint Slot { get; private set; }
+//        public abstract eDmInputCardType Type { get; }
+
+//        //public RoutingOutputPort BackplaneVideoOut { get; private set; }
+//        //public RoutingOutputPort BackplaneAudioOut { get; private set; }
+
+//        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+
+//        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+//        public DmInputCardControllerBase(string key, uint slot)
+//        {
+//            Key = key;
+//            Slot = slot;
+//            //BackplaneAudioOut = new RoutingOutputPort("backplaneAudioOut", eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.BackplaneOnly, slot, this);
+//            //BackplaneVideoOut = new RoutingOutputPort("backplaneVideoOut", eRoutingSignalType.Video,
+//            //    eRoutingPortConnectionType.BackplaneOnly, slot, this);
+//            //InputPorts = new RoutingPortCollection<RoutingInputPort>();
+//            //OutputPorts = new RoutingPortCollection<RoutingOutputPort> { BackplaneAudioOut, BackplaneVideoOut };
+//        }
+
+//        ///// <summary>
+//        ///// Gets a physical port by name.  Returns null if doesn't exist
+//        ///// </summary>
+//        //public RoutingInputPort GetInputPort(string key)
+//        //{
+//        //    return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+//        //}
+
+//        ///// <summary>
+//        ///// Gets a physical port by name.  Returns null if doesn't exist
+//        ///// </summary>
+//        //public RoutingOutputPort GetOutputPort(string key)
+//        //{
+//        //    return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+//        //}
+//    }
+
+//    public enum eDmInputCardType
+//    {
+//        None, DmcHd, DmcHdDsp, Dmc4kHd, Dmc4kHdDsp, Dmc4kC, Dmc4kCDsp
+//    }
+//}
--- a/REMOVE/DmOutputCardBase.cs
+++ b/REMOVE/DmOutputCardBase.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.DM.Cards
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public abstract class DmSingleOutputCardControllerBase// : IRoutingInputsOutputs
+	{
+		public string Key { get; private set; }
+		public uint Slot { get; private set; }
+		public abstract eDmOutputCardType Type { get; }
+
+        //public RoutingInputPort BackplaneAudioIn1 { get; private set; }
+        //public RoutingInputPort BackplaneVideoIn1 { get; private set; }
+        //public RoutingInputPort BackplaneAudioIn2 { get; private set; }
+        //public RoutingInputPort BackplaneVideoIn2 { get; private set; }
+
+        //public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        //public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		public DmSingleOutputCardControllerBase(string key, uint cardSlot)
+		{
+			Key = key;
+			Slot = cardSlot;
+            //BackplaneAudioIn1 = new RoutingInputPort("backplaneAudioIn1", eRoutingSignalType.Audio,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
+            //BackplaneVideoIn1 = new RoutingInputPort("backplaneVideoIn1", eRoutingSignalType.Video,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
+            //BackplaneAudioIn2 = new RoutingInputPort("backplaneAudioIn2", eRoutingSignalType.Audio,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
+            //BackplaneVideoIn2 = new RoutingInputPort("backplaneVideoIn2", eRoutingSignalType.Video,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
+            //InputPorts = new RoutingPortCollection<RoutingInputPort>
+            //{
+            //    BackplaneAudioIn1,
+            //    BackplaneAudioIn2,
+            //    BackplaneVideoIn1,
+            //    BackplaneVideoIn2
+            //};
+            //OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+		}
+
+		///// <summary>
+		///// Gets a physical port by name.  Returns null if doesn't exist
+		///// </summary>
+		//public RoutingInputPort GetInputPort(string key)
+		//{
+		//    return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+		//}
+
+        ///// <summary>
+        ///// Gets a physical port by name.  Returns null if doesn't exist
+        ///// </summary>
+        //public RoutingOutputPort GetOutputPort(string key)
+        //{
+        //    return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+        //}
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public enum eDmOutputCardType
+	{
+        None, Dmc4kCoHd, Dmc4kHdo, DmcCoHd, DmcSoHd
+	}
+}
--- a/REMOVE/Dmc4kCoHdSingleOutputCard.cs
+++ b/REMOVE/Dmc4kCoHdSingleOutputCard.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.DM.Cards
+{
+	public class Dmc4kCoHdSingleOutputCard : DmSingleOutputCardControllerBase
+	{
+		public override eDmOutputCardType Type
+		{
+			get { return eDmOutputCardType.Dmc4kCoHd; }
+		}
+		public Dmc4kCoHdSingle Card { get; private set; }
+
+        //public RoutingOutputPort DmOut1 { get; private set; }
+        //public RoutingOutputPort DmOut2 { get; private set; }
+        //public RoutingOutputPort HdmiOut1 { get; private set; }
+
+		public Dmc4kCoHdSingleOutputCard(string key, Dmc4kCoHdSingle card, uint slot)
+			: base(key, slot)
+		{
+			Card = card;
+            //DmOut1 = new RoutingOutputPort(DmPortName.DmOut1, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.DmCat, null, this);
+            //DmOut2 = new RoutingOutputPort(DmPortName.DmOut2, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.DmCat, null, this);
+            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+            //OutputPorts.AddRange(new[] { DmOut1, DmOut2, HdmiOut1 });
+		}
+	}
+}
--- a/REMOVE/Dmc4kHdoSingleOutputCard.cs
+++ b/REMOVE/Dmc4kHdoSingleOutputCard.cs
@@ -0,0 +1,46 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class Dmc4kHdoSingleOutputCard : DmSingleOutputCardControllerBase
+//    {
+//        public override eDmOutputCardType Type
+//        {
+//            get { return eDmOutputCardType.Dmc4kHdo; }
+//        }
+//        public Dmc4kHdoSingle Card { get; private set; }
+
+//        //public RoutingOutputPort AudioOut1 { get; private set; }
+//        //public RoutingOutputPort AudioOut2 { get; private set; }
+//        //public RoutingOutputPort HdmiOut1 { get; private set; }
+//        //public RoutingOutputPort HdmiOut2 { get; private set; }
+
+//        public Dmc4kHdoSingleOutputCard(string key, Dmc4kHdoSingle card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //AudioOut1 = new RoutingOutputPort(DmPortName.BalancedAudioOut1, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.LineAudio, null, this);
+//            //AudioOut2 = new RoutingOutputPort(DmPortName.BalancedAudioOut2, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.LineAudio, null, this);
+//            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //HdmiOut2 = new RoutingOutputPort(DmPortName.HdmiOut2, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //OutputPorts.AddRange(new[] { AudioOut1, AudioOut2, HdmiOut1, HdmiOut2 });
+//        }
+//    }
+//}
--- a/REMOVE/DmcC4kInputCard.cs
+++ b/REMOVE/DmcC4kInputCard.cs
@@ -0,0 +1,76 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class Dmc4kCController : DmInputCardControllerBase
+//    {
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kC; }
+//        }
+//        public Dmc4kC Card { get; private set; }
+
+//        //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+		
+//        public Dmc4kCController(string key, Dmc4kC card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.DmCat, null, this, 
+//            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(DmIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//    public class Dmc4kCDspController : DmInputCardControllerBase
+//    {
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kCDsp; }
+//        }
+//        public Dmc4kCDsp Card { get; private set; }
+
+//        //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kCDspController(string key, Dmc4kCDsp card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.DmCat, null, this,
+//            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(DmIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//}
--- a/REMOVE/DmcHD4kInputCard.cs
+++ b/REMOVE/DmcHD4kInputCard.cs
@@ -0,0 +1,82 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    /// <summary>
+//    /// 
+//    /// </summary>
+//    public class Dmc4kHdController : DmInputCardControllerBase
+//    {
+//        public Dmc4kHd Card { get; private set; }
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kHd; }
+//        }
+
+//        public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+//        public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kHdController(string key, Dmc4kHd card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//                eRoutingPortConnectionType.Hdmi, null, this,
+//                VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
+
+//            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//                eRoutingPortConnectionType.Hdmi, null, this);
+//            AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//                eRoutingPortConnectionType.Hdmi, null, this);
+
+//            InputPorts.Add(HdmiIn);
+//            OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//    /// <summary>
+//    /// 
+//    /// </summary>
+//    public class Dmc4kHdDspController : DmInputCardControllerBase
+//    {
+//        public Dmc4kHdDsp Card { get; private set; }
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kHdDsp; }
+//        }
+
+//        //public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kHdDspController(string key, Dmc4kHdDsp card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this,
+//            //    VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(HdmiIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+//}
+
--- a/DM/Essentials_DM/Chassis/DmCardAudioOutput.cs
+++ b/DM/Essentials_DM/Chassis/DmCardAudioOutput.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(0, 400);
+#warning SCALE THIS RAMP
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(65535, 400);
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}
--- a/DM/Essentials_DM/Chassis/DmChassisController.cs
+++ b/DM/Essentials_DM/Chassis/DmChassisController.cs
@@ -0,0 +1,569 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Cards;
+
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmChassisController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting//, ICardPortsDevice
+	{
+		public DmMDMnxn Chassis { get; private set; }
+
+		// Need a couple Lists of generic Backplane ports
+		public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        //public Dictionary<uint, DmInputCardControllerBase> InputCards { get; private set; }
+        //public Dictionary<uint, DmSingleOutputCardControllerBase> OutputCards { get; private set; }
+
+		public Dictionary<uint, string> InputNames { get; set; }
+		public Dictionary<uint, string> OutputNames { get; set; }
+        public Dictionary<uint, DmCardAudioOutputController> VolumeControls { get; private set; }
+
+		public const int RouteOffTime = 500;
+		Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
+
+		/// <summary>
+		/// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
+		/// </summary>
+		public static DmChassisController GetDmChassisController(string key, string name,
+			string type, DMChassisPropertiesConfig properties)
+		{
+			try
+			{
+				type = type.ToLower();
+				uint ipid = properties.Control.IpIdInt; // Convert.ToUInt16(properties.Id, 16);
+				DmChassisController controller = null;
+				if (type == "dmmd8x8")
+				{
+					controller = new DmChassisController(key, name, new DmMd8x8(ipid, Global.ControlSystem));
+                    // add the cards and port names
+                    foreach (var kvp in properties.InputSlots)
+                        controller.AddInputCard(kvp.Value, kvp.Key);
+    				foreach (var kvp in properties.OutputSlots)
+                        controller.AddOutputCard(kvp.Value, kvp.Key);
+                    foreach (var kvp in properties.VolumeControls)
+                    {
+                        // get the card
+                        // check it for an audio-compatible type
+                        // make a something-something that will make it work
+                        // retire to mountain village
+                        var outNum = kvp.Key;
+                        var card = controller.Chassis.Outputs[outNum].Card;
+                        Audio.Output audio = null;
+                        if (card is DmcHdo)
+                            audio = (card as DmcHdo).Audio;
+                        else if (card is Dmc4kHdo)
+                            audio = (card as Dmc4kHdo).Audio;
+                        if (audio == null)
+                            continue;
+                        // wire up the audio to something here...
+                        controller.AddVolumeControl(outNum, audio);
+                    }
+
+					controller.InputNames = properties.InputNames;
+					controller.OutputNames = properties.OutputNames;
+					return controller;
+				}
+			}
+			catch (System.Exception e)
+			{
+				Debug.Console(0, "Error creating DM chassis:\r{0}", e);
+			}
+			return null;
+		}
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="chassis"></param>
+		public DmChassisController(string key, string name, DmMDMnxn chassis)
+			: base(key, name, chassis)
+		{
+			Chassis = chassis;
+			InputPorts = new RoutingPortCollection<RoutingInputPort>();
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+            VolumeControls = new Dictionary<uint, DmCardAudioOutputController>();
+            IsOnline.OutputChange += new EventHandler<EventArgs>(IsOnline_OutputChange);
+            Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+		}
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="number"></param>
+        public void AddInputCard(string type, uint number)
+        {
+            Debug.Console(2, this, "Adding input card '{0}', slot {1}", type, number);
+            if (type == "dmc4kHd")
+            {
+                new Dmc4kHd(number, this.Chassis);
+                AddHdmiInCardPorts(number);
+            }
+            else if (type == "dmc4kHdDsp")
+            {
+                new Dmc4kHdDsp(number, this.Chassis);
+                AddHdmiInCardPorts(number);
+            }
+            else if (type == "dmc4kC")
+            {
+                new Dmc4kC(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmc4kCDsp")
+            {
+                new Dmc4kCDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcHd")
+            {
+                new DmcHd(number, this.Chassis);
+                AddHdmiInCardPorts(number);
+            }
+            else if (type == "dmcHdDsp")
+            {
+                new DmcHdDsp(number, this.Chassis);
+                AddHdmiInCardPorts(number);
+            }
+
+            else if (type == "dmcC")
+            {
+                new DmcC(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcCDsp")
+            {
+                new DmcCDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcS")
+            {
+                new DmcS(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInCardLoopPorts(number);
+            }
+            else if (type == "dmcSDsp")
+            {
+                new DmcSDsp(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInCardLoopPorts(number);
+            }
+            else if (type == "dmcS2")
+            {
+                new DmcS2(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInCardLoopPorts(number);
+            }
+            else if (type == "dmcS2Dsp")
+            {
+                new DmcS2Dsp(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInCardLoopPorts(number);
+            }
+            else if (type == "dmcSdi")
+            {
+                new DmcSdi(number, Chassis);
+                AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi);
+                AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi, null);
+                AddInCardLoopPorts(number);
+            }
+        }
+
+        void AddDmInCardPorts(uint number)
+        {
+            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
+            AddInCardLoopPorts(number);
+        }
+
+        void AddHdmiInCardPorts(uint number)
+        {
+            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi);
+            AddInCardLoopPorts(number);
+        }
+
+        void AddInCardLoopPorts(uint number)
+        {
+            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="number"></param>
+        public void AddOutputCard(string type, uint number)
+        {
+            Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
+            if (type == "dmc4kHdo")
+            {
+                new Dmc4kHdoSingle(number, Chassis);
+                AddDmcHdoPorts(number);
+            }
+            else if (type == "dmcHdo")
+            {
+                new DmcHdoSingle(number, Chassis);
+                AddDmcHdoPorts(number);
+            }
+            else if (type == "dmc4kCoHd")
+            {
+                new Dmc4kCoHdSingle(number, Chassis);
+                AddDmcCoPorts(number);
+            }
+            else if (type == "dmcCoHd")
+            {
+                new DmcCoHdSingle(number, Chassis);
+                AddDmcCoPorts(number);
+            }
+            else if (type == "dmcSoHd")
+            {
+                new DmcSoHdSingle(number, Chassis);
+                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
+
+            }
+            else if (type == "dmcS2oHd")
+            {
+                new DmcS2oHdSingle(number, Chassis);
+                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
+            }
+
+            else
+                Debug.Console(1, this, "  WARNING: Output card type '{0}' is not available", type);
+        }
+
+        void AddDmcHdoPorts(uint number)
+        {
+            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "hdmiOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2);
+            AddOutputPortWithDebug(number, "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
+
+        }
+
+        void AddDmcCoPorts(uint number)
+        {
+            AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType)
+        {
+            Debug.Console(2, this, "  Adding input port '{0}'", portName);
+            InputPorts.Add(new RoutingInputPort(string.Format("card{0}--{1}", cardNum, portName),
+                sigType, portType, cardNum, this));
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
+        {
+            Debug.Console(2, this, "  Adding output port '{0}'", portName);
+            OutputPorts.Add(new RoutingOutputPort(string.Format("card{0}--{1}", cardNum, portName),
+                sigType, portType, selector, this));
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void AddVolumeControl(uint number, Audio.Output audio)
+        {
+            VolumeControls.Add(number, new DmCardAudioOutputController(audio));
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
+        {
+            if (args.EventId == DMOutputEventIds.VolumeEventId &&
+                VolumeControls.ContainsKey(args.Number))
+                VolumeControls[args.Number].VolumeEventFromChassis();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pnt"></param>
+		void StartOffTimer(PortNumberType pnt)
+		{
+			if (RouteOffTimers.ContainsKey(pnt))
+				return;
+			RouteOffTimers[pnt] = new CTimer(o =>
+			{
+				ExecuteSwitch(0, pnt.Number, pnt.Type);
+			}, RouteOffTime);
+		}
+
+		// Send out sigs when coming online
+		void IsOnline_OutputChange(object sender, EventArgs e)
+		{
+			if (IsOnline.BoolValue)
+			{
+				if (InputNames != null)
+					foreach (var kvp in InputNames)
+						Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
+				if (OutputNames != null)
+					foreach(var kvp in OutputNames)
+						Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
+			}
+		}
+
+		#region IRouting Members
+
+		public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
+		{
+			Debug.Console(0, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
+
+			var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
+			var output = Convert.ToUInt32(outputSelector);
+			// Check to see if there's an off timer waiting on this and if so, cancel
+			var key = new PortNumberType(output, sigType);
+            if (input == 0)
+            {
+                StartOffTimer(key);
+            }
+            else
+			{
+				if(RouteOffTimers.ContainsKey(key))
+				{
+					Debug.Console(2, this, "{0} cancelling route off due to new source", output);
+					RouteOffTimers[key].Stop();
+					RouteOffTimers.Remove(key);
+				}
+			}
+
+			Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
+
+			// NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
+			if (sigType != eRoutingSignalType.Audio)
+			{
+				Chassis.VideoEnter.BoolValue = true;
+				Chassis.Outputs[output].VideoOut = inCard;
+			}
+
+			if (sigType != eRoutingSignalType.Video)
+			{
+				Chassis.AudioEnter.BoolValue = true;
+				Chassis.Outputs[output].AudioOut = inCard;
+			}
+		}
+
+		#endregion
+//        void AddInUseTrackerToPort(RoutingOutputPort port, eRoutingSignalType sigType)
+//        {
+//            port.InUseTracker.InUseFeedback.OutputChange += (o, a) =>
+//            {
+//#warning Can we add something here that will de-route based on breakaway, or does it even matter?
+//                if (!port.InUseTracker.InUseFeedback.BoolValue)
+//                    this.ExecuteSwitch(0, port.Selector, sigType);
+//            };
+//        }
+
+           
+        //[Obsolete]
+        //public void AddInputCard(uint slot, eDmInputCardType type)
+        //{
+        //    var cardKey = Key + "-inputCard" + slot;
+        //    switch (type)
+        //    {
+        //        case eDmInputCardType.Dmc4kHd:
+        //            InputCards[slot] = new Dmc4kHdController(cardKey, 
+        //                new Dmc4kHd(slot, this.Chassis), slot);
+        //            break;
+        //        case eDmInputCardType.Dmc4kHdDsp:
+        //            InputCards[slot] = new Dmc4kHdDspController(cardKey,
+        //                new Dmc4kHdDsp(slot, this.Chassis), slot);
+        //            break;
+        //        case eDmInputCardType.Dmc4kC:
+        //            InputCards[slot] = new Dmc4kCController(cardKey,
+        //                new Dmc4kC(slot, this.Chassis), slot);
+        //            break;
+        //        case eDmInputCardType.Dmc4kCDsp:
+        //            InputCards[slot] = new Dmc4kCDspController(cardKey,
+        //                new Dmc4kCDsp(slot, this.Chassis), slot);
+        //            break;
+        //    }
+        //}
+
+        //[Obsolete]
+        //public void AddOutputCard(uint cardSlot, eDmOutputCardType type)
+        //{
+        //    var cardKey = Key + "-outputCard" + cardSlot;
+        //    switch (type)
+        //    {
+        //        case eDmOutputCardType.Dmc4kCoHd:
+        //            OutputCards[cardSlot] = new Dmc4kCoHdSingleOutputCard(cardKey,
+        //                new Dmc4kCoHdSingle(cardSlot, this.Chassis), cardSlot);
+        //            break;
+        //        case eDmOutputCardType.DmcCoHd:
+        //            OutputCards[cardSlot] = new Dmc4kHdoSingleOutputCard(cardKey,
+        //                new Dmc4kHdoSingle(cardSlot, this.Chassis), cardSlot);
+        //            break;
+        //        default:
+        //            break;
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Helper to get a specific port from a given attached card
+        ///// </summary>
+        ///// <param name="card">Named 'input-N' ('output-N' is not valid, as output cards have no inputs)</param>
+        ///// <param name="port">The port name on the card, for example 'hdmiOut'</param>
+        ///// <returns>Returns port or null if doesn't exist</returns>
+        //public RoutingInputPort GetChildInputPort(string card, string port)
+        //{
+        //    return GetChildPort(card, port, false) as RoutingInputPort;
+        //}
+
+        ///// <summary>
+        ///// Helper to get a specific port from a given attached card
+        ///// </summary>
+        ///// <param name="card">Named 'input-N' or 'output-N'</param>
+        ///// <param name="port">The port name on the card, for example 'hdmiOut'</param>
+        ///// <returns>Returns port or null if doesn't exist</returns>
+        //public RoutingOutputPort GetChildOutputPort(string card, string port)
+        //{
+        //    return GetChildPort(card, port, true) as RoutingOutputPort;
+        //}
+
+        ///// <summary>
+        ///// Helper for above methods
+        ///// </summary>
+        //RoutingPort GetChildPort(string cardKey, string portKey, bool portIsOutput)
+        //{
+        //    var cardTokens = cardKey.Split('-');
+        //    if (cardTokens.Length != 2)
+        //    {
+        //        Debug.Console(0, this, "WARNING: GetChildPort cannot get port. Card parameter must be 'input-N' or 'output-N'");
+        //        return null;
+        //    }
+        //    try
+        //    {
+        //        uint slotNum = Convert.ToUInt32(cardTokens[1]);
+        //        var cardType = cardTokens[0].ToLower();
+        //        if (cardType == "input" && InputCards.ContainsKey(slotNum))
+        //        {
+        //            var card = InputCards[slotNum];
+        //            if (portIsOutput)
+        //                return card.GetOutputPort(portKey);
+        //            else
+        //                return card.GetInputPort(portKey);
+        //        }
+        //        if (cardType == "output" && OutputCards.ContainsKey(slotNum))
+        //        {
+        //            var card = OutputCards[slotNum];
+        //            return card.GetOutputPort(portKey);
+        //        }
+        //    }
+        //    catch (Exception)
+        //    {
+        //        Debug.Console(0, this, "WARNING: GetChildPort cannot get port. Only integer card numbers are valid.");
+        //    }
+        //    return null;
+        //}
+
+        //public override bool CustomActivate()
+        //{
+        //    var tlc = TieLineCollection.Default;
+        //    // Take all cards and TieLine them together with the internal ports
+        //    for (uint i = 1; i <= Chassis.NumberOfInputs; i++)
+        //    {
+        //        // If there's a matching input card for a given input number...
+        //        // This test *shouldn't* be necessary if data is consistent
+        //        if (InputCards.ContainsKey(i))
+        //        {
+        //            // Get the ports to link
+        //            var cardAudio = InputCards[i].BackplaneAudioOut;
+        //            var chassisAudio = InputPorts.FirstOrDefault(p => 
+        //                (uint)p.Selector == i && p.Type == eRoutingSignalType.Audio);
+        //            if (chassisAudio != null)
+        //                tlc.Add(new TieLine(cardAudio, chassisAudio));
+        //            else
+        //                Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
+        //                    "Backplane audio tie line creation for input card {0} failed", i);
+
+        //            // Repeat for video link
+        //            var cardVideo = InputCards[i].BackplaneVideoOut;
+        //            var chassisVideo = InputPorts.FirstOrDefault(p => 
+        //                (uint)p.Selector == i && p.Type == eRoutingSignalType.Video);
+        //            if (cardVideo != null)
+        //                tlc.Add(new TieLine(cardVideo, chassisVideo));
+        //            else
+        //                Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
+        //                    "Backplane video tie line creation for input card {0} failed", i);
+        //        }
+        //    }
+
+        //    // Loop through outputs and do it again - in pairs, because FYC
+        //    for (uint i = 1; i <= Chassis.NumberOfOutputs / 2; i += 1)
+        //    {
+        //        if (OutputCards.ContainsKey(i))
+        //        {
+        //            //Debug.Console(0, this, "Adding internal TieLines on output card {0}", OutputCards[i].Key);
+        //            // Left side of card
+        //            uint a = i * 2 - 1;
+        //            tlc.Add(new TieLine(
+        //                OutputPorts.First(p => (uint)p.Selector == a && p.Type == eRoutingSignalType.Audio), 
+        //                OutputCards[i].BackplaneAudioIn1));
+        //            tlc.Add(new TieLine(
+        //                OutputPorts.First(p => (uint)p.Selector == a && p.Type == eRoutingSignalType.Video), 
+        //                OutputCards[i].BackplaneVideoIn1));
+
+        //            // Right side of card
+        //            uint b = i * 2;
+        //            tlc.Add(new TieLine(
+        //                OutputPorts.First(p => (uint)p.Selector == b && p.Type == eRoutingSignalType.Audio),
+        //                OutputCards[i].BackplaneAudioIn2));
+        //            tlc.Add(new TieLine(
+        //                OutputPorts.First(p => (uint)p.Selector == b && p.Type == eRoutingSignalType.Video),
+        //                OutputCards[i].BackplaneVideoIn2));
+        //        }
+        //    }
+
+        //    // Base does register and sets up comm monitoring.
+        //    return base.CustomActivate();
+        //}
+
+	}
+
+	public struct PortNumberType
+	{
+		public uint Number { get; private set; }
+		public eRoutingSignalType Type { get; private set; }
+
+		public PortNumberType(uint number, eRoutingSignalType type) : this()
+		{
+			Number = number;
+			Type = type;
+		}
+	}
+}
--- a/DM/Essentials_DM/Config/DMChassisConfig.cs
+++ b/DM/Essentials_DM/Config/DMChassisConfig.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM device config
+	/// </summary>
+	public class DMChassisPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("volumeControls")]
+        public Dictionary<uint, DmCardAudioPropertiesConfig> VolumeControls { get; set; }
+
+        [JsonProperty("inputSlots")]
+        public Dictionary<uint, string> InputSlots { get; set; }
+
+        [JsonProperty("outputSlots")]
+        public Dictionary<uint, string> OutputSlots { get; set; }
+
+		[JsonProperty("inputNames")]
+		public Dictionary<uint, string> InputNames { get; set; }
+
+		[JsonProperty("outputNames")]
+		public Dictionary<uint, string> OutputNames { get; set; }
+	}
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class DmCardAudioPropertiesConfig
+    {
+        [JsonProperty("outLevel")]
+        public int OutLevel { get; set; }
+
+        [JsonProperty("isVolumeControlPoint")]
+        public bool IsVolumeControlPoint { get; set; }
+    }
+}
--- a/DM/Essentials_DM/Config/DeviceFactory.cs
+++ b/DM/Essentials_DM/Config/DeviceFactory.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharpPro;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DeviceFactory
+	{
+		public static IKeyed GetDevice(DeviceConfig dc)
+		{
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+
+			var typeName = dc.Type.ToLower();
+
+			if (typeName == "dmmd8x8")
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DMChassisPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmChassisController.
+					GetDmChassisController(key, name, type, props);
+			}
+
+			// Hand off to DmTxHelper class
+			else if (typeName.StartsWith("dmtx"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DmTxPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmTxHelper.GetDmTxController(key, name, type, props);
+			}
+
+			// Hand off to DmRmcHelper class
+			else if (typeName.StartsWith("dmrmc"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DmRmcPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmRmcHelper.GetDmRmcController(key, name, type, props);
+			}
+
+			return null;
+		}
+
+
+	}
+
+}
--- a/DM/Essentials_DM/Config/DmRmcConfig.cs
+++ b/DM/Essentials_DM/Config/DmRmcConfig.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM TX device config
+	/// </summary>
+	public class DmRmcPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+		[JsonProperty("parentDeviceKey")]
+		public string ParentDeviceKey { get; set; }
+
+		[JsonProperty("parentOutputNumber")]
+		public uint ParentOutputNumber { get; set; }
+	}
+}
--- a/DM/Essentials_DM/Config/DmTxConfig.cs
+++ b/DM/Essentials_DM/Config/DmTxConfig.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM TX device config
+	/// </summary>
+	public class DmTxPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+		[JsonProperty("parentDeviceKey")]
+		public string ParentDeviceKey { get; set; }
+
+		[JsonProperty("parentInputNumber")]
+		public uint ParentInputNumber { get; set; }
+
+		[JsonProperty("autoSwitching")]
+		public bool AutoSwitching { get; set; }
+	}
+}
--- a/DM/Essentials_DM/DmPortName.cs
+++ b/DM/Essentials_DM/DmPortName.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Constants for consistent port naming
+	/// </summary>
+	public class DmPortName
+	{
+		public const string AnyVideoIn = "AnyVideoIn";
+		public const string AudioLoopOut = "AudioLoopOut";
+		public const string BalancedAudioOut = "BalancedAudioOut";
+        public const string BalancedAudioOut1 = "BalancedAudioOut1";
+        public const string BalancedAudioOut2 = "BalancedAudioOut2";
+        public const string CompositeIn = "CompositeIn";
+		public const string DisplayPortIn = "DisplayPortIn";
+		public const string DmIn = "DmIn";
+		public const string DmOut = "DmOut";
+		public const string DmOut1 = "DmOut1";
+		public const string DmOut2 = "DmOut2";
+		public const string HdmiIn = "HdmiIn";
+		public const string HdmiIn1 = "HdmiIn1";
+		public const string HdmiIn2 = "HdmiIn2";
+		public const string HdmiOut1 = "HdmiOut1";
+        public const string HdmiOut2 = "HdmiOut2";
+        public const string HdmiLoopOut = "HdmiLoopOut";
+		public const string HdmiOut = "HdmiOut";
+		public const string VgaIn = "VgaIn";
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc100CController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc100CController.cs
@@ -0,0 +1,70 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmc100CController : DmRmcControllerBase, IRoutingInputsOutputs, 
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmc100C Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmc100CController(string key, string name, DmRmc100C rmc)
+			: base(key, name, rmc)
+		{
+			Rmc = rmc;
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, 0, this);
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+		}
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return Rmc.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return Rmc.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return Rmc.ComPorts; } }
+		public int NumberOfComPorts { get { return Rmc.NumberOfComPorts; } }
+		#endregion
+
+		#region ICec Members
+		public Cec StreamCec { get { return Rmc.StreamCec; } }
+		#endregion
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs
@@ -0,0 +1,156 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmc4kScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
+		IIROutputPorts, IComPorts, ICec, IRelayPorts
+	{
+		public DmRmc4kScalerC Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingOutputPort BalancedAudioOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut, BalancedAudioOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmc4kScalerCController(string key, string name, DmRmc4kScalerC rmc)
+			: base(key, name, rmc)
+		{
+			Rmc = rmc;
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, 0, this);
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+			BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
+				eRoutingPortConnectionType.LineAudio, null, this);
+
+			MuteFeedback = new BoolFeedback(() => false);
+			VolumeLevelFeedback = new IntFeedback(CommonIntCue.MainVolumeLevelFeedback, () => 
+				rmc.AudioOutput.VolumeFeedback.UShortValue);
+		}
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return Rmc.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return Rmc.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return Rmc.ComPorts; } }
+		public int NumberOfComPorts { get { return Rmc.NumberOfComPorts; } }
+		#endregion
+
+		#region ICec Members
+		/// <summary>
+		/// Gets the CEC stream directly from the HDMI port.
+		/// </summary>
+		public Cec StreamCec { get { return Rmc.HdmiOutput.StreamCec; } }
+		#endregion
+
+		#region IRelayPorts Members
+
+		public int NumberOfRelayPorts
+		{
+			get { return Rmc.NumberOfRelayPorts; }
+		}
+
+		public CrestronCollection<Relay> RelayPorts
+		{
+			get { return Rmc.RelayPorts; }
+		}
+
+		#endregion
+
+		#region IBasicVolumeWithFeedback Members
+
+		public BoolFeedback MuteFeedback
+		{
+			get;
+			private set;
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		public void MuteOff()
+		{	
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		public void MuteOn()
+		{
+		}
+
+		public void SetVolume(ushort level)
+		{
+			Rmc.AudioOutput.Volume.UShortValue = level;
+		}
+
+		public IntFeedback VolumeLevelFeedback
+		{
+			get;
+			private set;
+		}
+
+		#endregion
+
+		#region IBasicVolumeControls Members
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		public void MuteToggle()
+		{
+		}
+
+		public void VolumeDown(bool pressRelease)
+		{
+			if (pressRelease)
+				SigHelper.RampTimeScaled(Rmc.AudioOutput.Volume, 0, 4000);
+			else
+				Rmc.AudioOutput.Volume.StopRamp();
+		}
+
+		public void VolumeUp(bool pressRelease)
+		{
+			if (pressRelease)
+				SigHelper.RampTimeScaled(Rmc.AudioOutput.Volume, 65535, 4000);
+			else
+				Rmc.AudioOutput.Volume.StopRamp();
+		}
+
+		#endregion
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcHelper.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcHelper.cs
@@ -0,0 +1,138 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public abstract class DmRmcControllerBase : CrestronGenericBaseDevice
+	{
+		public DmRmcControllerBase(string key, string name, EndpointReceiverBase device)
+			: base(key, name, device)
+		{ }
+	}
+
+	public class DmRmcHelper
+	{
+		/// <summary>
+		/// A factory method for various DmTxControllers
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="props"></param>
+		/// <returns></returns>
+		public static DmRmcControllerBase GetDmRmcController(string key, string name, string typeName, DmRmcPropertiesConfig props)
+		{
+			// switch on type name... later...
+
+			typeName = typeName.ToLower();
+			uint ipid = props.Control.IpIdInt; // Convert.ToUInt16(props.Id, 16);
+
+
+
+            // right here, we need to grab the tie line that associates this
+            // RMC with a chassis or processor.  If the RMC input's tie line is not
+            // connected to a chassis, then it's parent is the processor.
+            // If the RMC is connected to a chassis, then we need to grab the 
+            // output number from the tie line and use that to plug it in.
+            // Example of chassis-connected:
+            //{
+            //  "sourceKey": "dmMd8x8-1",
+            //  "sourcePort": "anyOut2",
+            //  "destinationKey": "dmRmc100C-2",
+            //  "destinationPort": "DmIn"
+            //}
+
+            // Tx -> RMC link:
+            //{
+            //  "sourceKey": "dmTx201C-1",
+            //  "sourcePort": "DmOut",
+            //  "destinationKey": "dmRmc100C-2",
+            //  "destinationPort": "DmIn"
+            //}
+
+            var tlc = TieLineCollection.Default;
+            // grab the tie line that has this key as 
+            // THIS DOESN'T WORK BECAUSE THE RMC THAT WE NEED (THIS) HASN'T BEEN MADE
+            // YET AND THUS WILL NOT HAVE A TIE LINE...
+            var inputTieLine = tlc.FirstOrDefault(t => 
+                {
+                    var d = t.DestinationPort.ParentDevice;
+                    return d.Key.Equals(key, StringComparison.OrdinalIgnoreCase)
+                        && d is DmChassisController;
+                });
+
+			var pKey = props.ParentDeviceKey.ToLower();
+
+
+
+
+			// Non-DM-chassis endpoints
+			if (pKey == "processor")
+			{
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+					if (typeName.StartsWith("dmrmc100c"))
+						return new DmRmc100CController(key, name, new DmRmc100C(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmrmcscalerc"))
+						return new DmRmcScalerCController(key, name, new DmRmcScalerC(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmrmc4kscalerc"))
+						return new DmRmc4kScalerCController(key, name, new DmRmc4kScalerC(ipid, Global.ControlSystem));
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
+				}
+
+
+				Debug.Console(0, "Cannot create DM-RMC of type: '{0}'", typeName);
+			}
+			// Endpoints attached to DM Chassis
+			else
+			{
+				var parentDev = DeviceManager.GetDeviceForKey(pKey);
+				if (!(parentDev is DmChassisController))
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
+						key, pKey);
+					return null;
+				}
+
+				var chassis = (parentDev as DmChassisController).Chassis;
+				var num = props.ParentOutputNumber;
+				if (num <= 0 || num > chassis.NumberOfOutputs)
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. Output number '{1}' is out of range",
+						key, num);
+					return null;
+				}
+
+				try
+				{
+					if (typeName.StartsWith("dmrmc100c"))
+						return new DmRmc100CController(key, name, new DmRmc100C(ipid, chassis.Outputs[num]));
+					if (typeName.StartsWith("dmrmcscalerc"))
+						return new DmRmcScalerCController(key, name, new DmRmcScalerC(ipid, chassis.Outputs[num]));
+					if (typeName.StartsWith("dmrmc4kscalerc"))
+						return new DmRmc4kScalerCController(key, name, new DmRmc4kScalerC(ipid, chassis.Outputs[num]));
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
+				}
+			}
+
+			return null;
+		}
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerCController.cs
+++ b/DM/Essentials_DM/Endpoints/Receivers/DmRmcScalerCController.cs
@@ -0,0 +1,73 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmcScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, 
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmcScalerC Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmcScalerCController(string key, string name, DmRmcScalerC rmc)
+			: base(key, name, rmc)
+		{
+			Rmc = rmc;
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, 0, this);
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+		}
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return Rmc.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return Rmc.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return Rmc.ComPorts; } }
+		public int NumberOfComPorts { get { return Rmc.NumberOfComPorts; } }
+		#endregion
+
+		#region ICec Members
+		/// <summary>
+		/// Gets the CEC stream directly from the HDMI port.
+		/// </summary>
+		public Cec StreamCec { get { return Rmc.HdmiOutput.StreamCec; } }
+		#endregion
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx201CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx201CController.cs
@@ -0,0 +1,196 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DmTx201SBasicController : DmTxControllerBase, IRoutingInputsOutputs, IHasFeedback
+	{
+		public DmTx201S Tx { get; private set; }
+
+		public RoutingInputPortWithVideoStatuses AnyVideoInput { get; private set; }
+		public RoutingInputPortWithVideoStatuses HdmiInput { get; private set; }
+		public RoutingInputPortWithVideoStatuses VgaInput { get; private set; }
+		public RoutingOutputPort DmOutput { get; private set; }
+		public StringFeedback ActiveVideoInputFeedback { get; private set; }
+
+		/// <summary>
+		/// Helps get the "real" inputs, including when in Auto
+		/// </summary>
+		public DmTx200Base.eSourceSelection ActualVideoInput
+		{
+			get
+			{
+				if (Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Digital ||
+						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Analog ||
+						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Disable)
+					return Tx.VideoSourceFeedback;
+				else // auto
+				{
+					if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+						return DmTx200Base.eSourceSelection.Digital;
+					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+						return DmTx200Base.eSourceSelection.Analog;
+					else
+						return DmTx200Base.eSourceSelection.Disable;
+				}
+			}
+		}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiInput, 
+					VgaInput, 
+					AnyVideoInput 
+				};
+			}
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingOutputPort> { DmOutput };
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="tx"></param>
+		public DmTx201SBasicController(string key, string name, DmTx201S tx)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			//Can this be combined into helper somehow??
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					ActualVideoInput == DmTx200Base.eSourceSelection.Digital
+					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue,
+
+				HdcpStateFeedbackFunc = () =>
+					ActualVideoInput == DmTx200Base.eSourceSelection.Digital
+					? tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString()
+					: "",
+
+				VideoResolutionFeedbackFunc = () =>
+					ActualVideoInput == DmTx200Base.eSourceSelection.Digital
+					? Tx.HdmiInput.VideoAttributes.GetVideoResolutionString()
+					: Tx.VgaInput.VideoAttributes.GetVideoResolutionString(),
+
+				VideoSyncFeedbackFunc = () =>
+					ActualVideoInput == DmTx200Base.eSourceSelection.Digital
+					? HdmiInput.VideoStatus.VideoSyncFeedback.BoolValue
+					: VgaInput.VideoStatus.VideoSyncFeedback.BoolValue
+			};
+			HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 1, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
+			VgaInput = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+				eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, 2, this, 
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.DmCat, null, this);
+			
+			ActiveVideoInputFeedback = new StringFeedback(new Cue("ActiveVideoInput", 0, eCueType.String),
+				() => ActualVideoInput.ToString());
+		}
+
+		public override bool CustomActivate()
+		{
+			Tx.HdmiInput.InputStreamChange += (o, a) => FireInputStreamChange(HdmiInput, a.EventId);
+			Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
+
+			Tx.VgaInput.InputStreamChange += (o, a) => FireInputStreamChange(VgaInput, a.EventId);
+			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(VgaInput, a.EventId);
+
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+		{
+			var id = args.EventId;
+			if (id == DmTx201S.VideoSourceFeedbackEventID)
+			{
+				Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+			}
+
+			// ------------------------------ incomplete -----------------------------------------
+			else if (id == DmTx201S.AudioSourceFeedbackEventID)
+			{
+				Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+			}
+		}
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FireInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+				AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+			}
+		}
+		
+		/// <summary>
+		/// Relays the VideoAttributes change to a RoutingInputPort
+		/// </summary>
+		void FireVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+			switch (eventId)
+			{
+				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					break;
+			}
+		}
+
+		public override List<Feedback> Feedbacks
+		{
+			get
+			{
+				List<Feedback> list = AnyVideoInput.VideoStatus.ToList();
+				list.AddRange(base.Feedbacks);
+				list.Add(ActiveVideoInputFeedback);
+				return list;
+			}
+		}
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx401CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx401CController.cs
@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//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;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	using eVst = DmTx401C.eSourceSelection;
+
+	public class DmTx401CController : DmTxControllerBase, IRoutingInputsOutputs, IHasFeedback, IIROutputPorts, IComPorts
+	{
+		public DmTx401C Tx { get; private set; }
+
+		public RoutingInputPortWithVideoStatuses AnyVideoInput { get; private set; }
+		public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses DisplayPortIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses CompositeIn { get; private set; }
+		public RoutingOutputPort DmOut { get; private set; }
+
+		public StringFeedback ActiveVideoInputFeedback { get; private set; }
+
+		/// <summary>
+		/// Helps get the "real" inputs, including when in Auto
+		/// </summary>
+		public BaseDmTx401.eSourceSelection ActualVideoInput
+		{
+			get
+			{
+				if (Tx.VideoSourceFeedback != BaseDmTx401.eSourceSelection.Auto)
+					return Tx.VideoSourceFeedback;
+				else // auto
+				{
+					if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.HDMI;
+					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.VGA;
+					else if (Tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.DisplayPort;
+					else if (Tx.CvbsInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.Composite;
+					else
+						return BaseDmTx401.eSourceSelection.Disabled;
+				}
+			}
+		}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn,
+					DisplayPortIn,
+					VgaIn, 
+					CompositeIn,
+					AnyVideoInput 
+				};
+			}
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingOutputPort> { DmOut };
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="tx"></param>
+		public DmTx401CController(string key, string name, DmTx401C tx)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 1, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
+			DisplayPortIn = new RoutingInputPortWithVideoStatuses(DmPortName.DisplayPortIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2, this,
+				VideoStatusHelper.GetDisplayPortInputStatusFuncs(tx.DisplayPortInput));
+			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+				eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, 3, this, 
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+			CompositeIn = new RoutingInputPortWithVideoStatuses(DmPortName.CompositeIn,
+				eRoutingSignalType.Video, eRoutingPortConnectionType.Composite, 3, this,
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+
+			ActiveVideoInputFeedback = new StringFeedback(new Cue("ActiveVideoInput", 0, eCueType.String),
+				() => ActualVideoInput.ToString());
+
+
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					(ActualVideoInput == eVst.HDMI
+					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.DisplayPort
+					&& tx.DisplayPortInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+				HdcpStateFeedbackFunc = () =>
+				{
+					if (ActualVideoInput == eVst.HDMI)
+						return tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString();
+					if (ActualVideoInput == eVst.DisplayPort)
+						return tx.DisplayPortInput.VideoAttributes.HdcpStateFeedback.ToString();
+					return "";
+				},
+
+				VideoResolutionFeedbackFunc = () =>
+				{
+					if (ActualVideoInput == eVst.HDMI)
+						return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.DisplayPort)
+						return tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.VGA)
+						return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.Composite)
+						return tx.CvbsInput.VideoAttributes.GetVideoResolutionString();
+					return "";
+				},
+				VideoSyncFeedbackFunc = () =>
+					(ActualVideoInput == eVst.HDMI
+					&& tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.DisplayPort
+					&& tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.VGA
+					&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.Composite
+					&& tx.CvbsInput.SyncDetectedFeedback.BoolValue)
+			};
+
+			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, null, this);
+		}
+
+		public override bool CustomActivate()
+		{
+			// Link up all of these damned events to the various RoutingPorts via a helper handler
+			Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn, a.EventId);
+			Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn, a.EventId);
+
+			Tx.DisplayPortInput.InputStreamChange += (o, a) => FowardInputStreamChange(DisplayPortIn, a.EventId);
+			Tx.DisplayPortInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(DisplayPortIn, a.EventId);
+
+			Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaIn, a.EventId);
+			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(VgaIn, a.EventId);
+
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+		{
+			var id = args.EventId;
+			if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+			}
+
+			// ------------------------------ incomplete -----------------------------------------
+			else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+			}
+		}
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+				AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+			}
+		}
+		
+		/// <summary>
+		/// Relays the VideoAttributes change to a RoutingInputPort
+		/// </summary>
+		void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+			switch (eventId)
+			{
+				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					break;
+			}
+		}
+
+		public override List<Feedback> Feedbacks
+		{
+			get
+			{
+				List<Feedback> list = AnyVideoInput.VideoStatus.ToList();
+				list.AddRange(base.Feedbacks);
+				list.Add(ActiveVideoInputFeedback);
+				return list;
+			}
+		}
+
+		#region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
+		public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
+		#endregion
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs
@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//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;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+
+	public class DmTx4k302CController : DmTxControllerBase, IRoutingInputsOutputs, IHasFeedback, 
+		IIROutputPorts, IComPorts
+	{
+		public DmTx4k302C Tx { get; private set; }
+
+		public RoutingInputPortWithVideoStatuses AnyVideoInput { get; private set; }
+		public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
+		public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
+		public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }
+		public RoutingOutputPort DmOut { get; private set; }
+		public RoutingOutputPort HdmiLoopOut { get; private set; }
+
+		public StringFeedback ActiveVideoInputFeedback { get; private set; }
+
+		/// <summary>
+		/// Helps get the "real" inputs, including when in Auto
+		/// </summary>
+		public Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType ActualActiveVideoInput
+		{
+			get
+			{
+				if (Tx.VideoSourceFeedback != eVst.Auto)
+					return Tx.VideoSourceFeedback;
+				else // auto
+				{
+					if (Tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+						return eVst.Hdmi1;
+					else if (Tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+						return eVst.Hdmi2;
+					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+						return eVst.Vga;
+					else
+						return eVst.AllDisabled;
+				}
+			}
+		}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn1,
+					HdmiIn2,
+					VgaIn, 
+					AnyVideoInput 
+				};
+			}
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="tx"></param>
+		public DmTx4k302CController(string key, string name, DmTx4k302C tx)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 1, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
+			HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
+			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+				eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, 3, this, 
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+			ActiveVideoInputFeedback = new StringFeedback(new Cue("ActiveVideoInput", 0, eCueType.String),
+				() => ActualActiveVideoInput.ToString());
+
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					(ActualActiveVideoInput == eVst.Hdmi1
+					&& tx.HdmiInputs[1].VideoAttributes.HdcpActiveFeedback.BoolValue)
+					|| (ActualActiveVideoInput == eVst.Hdmi2
+					&& tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+				HdcpStateFeedbackFunc = () =>
+					{
+						if (ActualActiveVideoInput == eVst.Hdmi1)
+							return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString();
+						if (ActualActiveVideoInput == eVst.Hdmi2)
+							return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+						return "";
+					},
+
+				VideoResolutionFeedbackFunc = () =>
+					{
+						if (ActualActiveVideoInput == eVst.Hdmi1)
+							return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
+						if (ActualActiveVideoInput == eVst.Hdmi2)
+							return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+						if (ActualActiveVideoInput == eVst.Vga)
+							return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+						return "";
+					},
+				VideoSyncFeedbackFunc = () =>
+					(ActualActiveVideoInput == eVst.Hdmi1
+					&& tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+					|| (ActualActiveVideoInput == eVst.Hdmi2
+					&& tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+					|| (ActualActiveVideoInput == eVst.Vga
+					&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
+			};
+
+			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, null, this);
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, null, this);
+		}
+
+		public override bool CustomActivate()
+		{
+			// Link up all of these damned events to the various RoutingPorts via a helper handler
+			Tx.HdmiInputs[1].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn1, a.EventId);
+			Tx.HdmiInputs[1].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn1, a.EventId);
+
+			Tx.HdmiInputs[2].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn2, a.EventId);
+			Tx.HdmiInputs[2].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn2, a.EventId);
+
+			Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaIn, a.EventId);
+			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(VgaIn, a.EventId);
+
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+		{
+			var id = args.EventId;
+			if (id == DmTx4k302C.VideoSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+			}
+
+			// ------------------------------ incomplete -----------------------------------------
+			else if (id == DmTx4k302C.AudioSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+			}
+		}
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+				AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+			}
+		}
+		
+		/// <summary>
+		/// Relays the VideoAttributes change to a RoutingInputPort
+		/// </summary>
+		void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+			switch (eventId)
+			{
+				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					break;
+			}
+		}
+
+		public override List<Feedback> Feedbacks
+		{
+			get
+			{
+				List<Feedback> list = AnyVideoInput.VideoStatus.ToList();
+				list.AddRange(base.Feedbacks);
+				list.Add(ActiveVideoInputFeedback);
+				return list;
+			}
+		}
+
+		#region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
+		public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
+		#endregion
+	}
+}
--- a/DM/Essentials_DM/Endpoints/Transmitters/DmTxHelpers.cs
+++ b/DM/Essentials_DM/Endpoints/Transmitters/DmTxHelpers.cs
@@ -0,0 +1,105 @@
+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.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DmTxHelper
+	{
+		/// <summary>
+		/// A factory method for various DmTxControllers
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="props"></param>
+		/// <returns></returns>
+		public static DmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
+		{
+			// switch on type name... later...
+
+			typeName = typeName.ToLower();
+			//uint ipid = Convert.ToUInt16(props.Id, 16);
+			var ipid = props.Control.IpIdInt;
+			var pKey = props.ParentDeviceKey.ToLower();
+
+			if (pKey == "processor")
+			{
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+					if (typeName.StartsWith("dmtx201"))
+						return new DmTx201SBasicController(key, name, new DmTx201C(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx4k302"))
+						return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx401"))
+						return new DmTx401CController(key, name, new DmTx401C(ipid, Global.ControlSystem));
+					Debug.Console(0, "{1} WARNING: Cannot create DM-TX of type: '{0}'", typeName, key);
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e.Message);
+				}
+			}
+			else
+			{
+				var parentDev = DeviceManager.GetDeviceForKey(pKey);
+				if (!(parentDev is DmChassisController))
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
+						key, pKey);
+					return null;
+				}
+
+                // Get the Crestron chassis and link stuff up
+				var switchDev = parentDev as DmChassisController;
+				var chassis = switchDev.Chassis;
+
+				var num = props.ParentInputNumber;
+				if (num <= 0 || num > chassis.NumberOfInputs)
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'.  Input number '{1}' is out of range",
+						key, num);
+					return null;
+				}
+
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+					if (typeName.StartsWith("dmtx201"))
+						return new DmTx201SBasicController(key, name, new DmTx201S(ipid, chassis.Inputs[num]));
+
+					if (typeName.StartsWith("dmtx4k302"))
+						return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, chassis.Inputs[num]));
+
+					if (typeName.StartsWith("dmtx401"))
+						return new DmTx401CController(key, name, new DmTx401C(ipid, chassis.Inputs[num]));
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e.Message);
+				}
+			}
+			
+			return null;
+		}
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public abstract class DmTxControllerBase : CrestronGenericBaseDevice
+	{
+		public DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
+			: base(key, name, hardware) { }
+	}
+}
--- a/DM/Essentials_DM/Essentials_DM.csproj
+++ b/DM/Essentials_DM/Essentials_DM.csproj
@@ -0,0 +1,126 @@
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{9199CE8A-0C9F-4952-8672-3EED798B284F}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PepperDash.Essentials.DM</RootNamespace>
+    <AssemblyName>PepperDash_Essentials_DM</AssemblyName>
+    <ProjectTypeGuids>{0B4745B0-194B-4BB6-8E21-E9057CA92300};{4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <PlatformFamilyName>WindowsCE</PlatformFamilyName>
+    <PlatformID>E2BECB1F-8C8C-41ba-B736-9BE7D946A398</PlatformID>
+    <OSVersion>5.0</OSVersion>
+    <DeployDirSuffix>SmartDeviceProject1</DeployDirSuffix>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <NativePlatformName>Windows CE</NativePlatformName>
+    <FormFactorID>
+    </FormFactorID>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugType>none</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Crestron.SimplSharpPro.DeviceSupport, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DeviceSupport.dll</HintPath>
+    </Reference>
+    <Reference Include="Crestron.SimplSharpPro.DM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DM.dll</HintPath>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="PepperDash_Core, Version=1.0.0.15153, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\pepperdash-simplsharp-core\Pepperdash Core\Pepperdash Core\bin\PepperDash_Core.dll</HintPath>
+    </Reference>
+    <Reference Include="PepperDash_Essentials_Core, Version=1.0.0.24856, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\essentials-core\PepperDashEssentialsBase\PepperDashEssentialsBase\bin\PepperDash_Essentials_Core.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpHelperInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpNewtonsoft, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpNewtonsoft.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpPro, Version=1.5.2.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Cards REMOVE\Dmc4kHdoSingleOutputCard.cs" />
+    <Compile Include="Cards REMOVE\Dmc4kCoHdSingleOutputCard.cs" />
+    <Compile Include="Cards REMOVE\DmOutputCardBase.cs" />
+    <Compile Include="Cards REMOVE\DmcC4kInputCard.cs" />
+    <Compile Include="Cards REMOVE\DmcHD4kInputCard.cs" />
+    <Compile Include="Cards REMOVE\DmInputCardBase.cs" />
+    <Compile Include="Chassis\DmCardAudioOutput.cs" />
+    <Compile Include="Chassis\DmChassisController.cs" />
+    <Compile Include="Config\DmRmcConfig.cs" />
+    <Compile Include="Config\DmTxConfig.cs" />
+    <Compile Include="Config\DMChassisConfig.cs" />
+    <Compile Include="DmPortName.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc4KScalerCController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcScalerCController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc100CController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcHelper.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx401CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx4k302CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx201CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTxHelpers.cs" />
+    <Compile Include="Extensions.cs" />
+    <Compile Include="Config\DeviceFactory.cs" />
+    <Compile Include="IDmHdmiInputExtensions.cs" />
+    <Compile Include="MOVE IBasicVideoStatusFeedbacks.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="VideoStatusHelpers.cs" />
+    <None Include="Properties\ControlSystem.cfg" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
+  <ProjectExtensions>
+    <VisualStudio>
+    </VisualStudio>
+  </ProjectExtensions>
+  <PropertyGroup>
+    <PostBuildEvent>rem S# Pro preparation will execute after these operations</PostBuildEvent>
+  </PropertyGroup>
+</Project>
--- a/DM/Essentials_DM/Essentials_DM.projectinfo
+++ b/DM/Essentials_DM/Essentials_DM.projectinfo
--- a/DM/Essentials_DM/Extensions.cs
+++ b/DM/Essentials_DM/Extensions.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	public static class VideoAttributesBasicExtensions
+	{
+		public static string GetVideoResolutionString(this VideoAttributesBasic va)
+		{
+			ushort h = va.HorizontalResolutionFeedback.UShortValue;
+			ushort v = va.VerticalResolutionFeedback.UShortValue;
+			if (h == 0 || v == 0)
+				return "n/a";
+			else
+				return string.Format("{0}x{1}", h, v);
+		}
+	}
+}
--- a/DM/Essentials_DM/IDmHdmiInputExtensions.cs
+++ b/DM/Essentials_DM/IDmHdmiInputExtensions.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	public static class IBasicDmInputExtensions
+	{
+		public static VideoStatusFuncsWrapper GetVideoStatusFuncsWrapper(this IBasicDMInput input)
+		{
+			var va = (input as IVideoAttributesEnhanced).VideoAttributes;
+			return new VideoStatusFuncsWrapper 
+			{
+				HasVideoStatusFunc = () => true,
+				HdcpActiveFeedbackFunc = () => va.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => va.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => 
+					{
+						var h = va.HorizontalResolutionFeedback.UShortValue;
+						var v = va.VerticalResolutionFeedback.UShortValue;
+						if (h == 0 || v == 0)
+							return "---";
+						return h + "x" + v;
+					},
+				VideoSyncFeedbackFunc = () => input.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+
+
+	public static class IEndpointHdmiInputExtensions
+	{
+		public static VideoStatusFuncsWrapper GetVideoStatusFuncsWrapper(this Crestron.SimplSharpPro.DM.Endpoints.EndpointHdmiInput input)
+		{
+			var va = (input as IVideoAttributesEnhanced).VideoAttributes;
+			return new VideoStatusFuncsWrapper
+			{
+				HasVideoStatusFunc = () => true,
+				HdcpActiveFeedbackFunc = () => va.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => va.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () =>
+				{
+					var h = va.HorizontalResolutionFeedback.UShortValue;
+					var v = va.VerticalResolutionFeedback.UShortValue;
+					if (h == 0 || v == 0)
+						return "---";
+					return h + "x" + v;
+				},
+				VideoSyncFeedbackFunc = () => input.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+
+
+}
--- a/IBasicVideoStatusFeedbacks.cs
+++ b/IBasicVideoStatusFeedbacks.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    public interface IBasicVideoStatusFeedbacks 
+    {
+		BoolFeedback HasVideoStatusFeedback { get; }
+		BoolFeedback HdcpActiveFeedback { get; }
+		StringFeedback HdcpStateFeedback { get; }
+		StringFeedback VideoResolutionFeedback { get; }
+		BoolFeedback VideoSyncFeedback { get; }
+    }
+}
--- a/DM/Essentials_DM/Properties/AssemblyInfo.cs
+++ b/DM/Essentials_DM/Properties/AssemblyInfo.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+[assembly: AssemblyTitle("Essentials_DM")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Essentials_DM")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyVersion("1.0.0.*")]
+
--- a/DM/Essentials_DM/Properties/ControlSystem.cfg
+++ b/DM/Essentials_DM/Properties/ControlSystem.cfg
--- a/DM/Essentials_DM/VideoStatusHelpers.cs
+++ b/DM/Essentials_DM/VideoStatusHelpers.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// These methods will get the funcs that return values from various video port types...
+	/// </summary>
+	public class VideoStatusHelper
+	{
+		public static VideoStatusFuncsWrapper GetHdmiInputStatusFuncs(HdmiInputPort port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetHdmiInputStatusFuncs(EndpointHdmiInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetVgaInputStatusFuncs(EndpointVgaInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetDmInputStatusFuncs(DMInputPort port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetDisplayPortInputStatusFuncs(EndpointDisplayPortInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+}