[deb_libcec.git] / src / LibCecSharp / CecSharpTypes.h

#pragma once
/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited.  All rights reserved.
 * libCEC(R) is an original work, containing original code.
 *
 * libCEC(R) is a trademark of Pulse-Eight Limited.
 *
 * This program is dual-licensed; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * Alternatively, you can license this library under a commercial license,
 * please contact Pulse-Eight Licensing for more information.
 *
 * For more information contact:
 * Pulse-Eight Licensing       <license@pulse-eight.com>
 *     http://www.pulse-eight.com/
 *     http://www.pulse-eight.net/
 */

#include <windows.h>
#include <vcclr.h>
#include <msclr/marshal.h>
#include "../../include/cec.h"

#using <System.dll>

namespace CecSharp
{
	public enum class CecDeviceType
	{
		Tv              = 0,
		RecordingDevice = 1,
		Reserved        = 2,
		Tuner           = 3,
		PlaybackDevice  = 4,
		AudioSystem     = 5
	};

	public enum class CecLogLevel
	{
		None    = 0,
		Error   = 1,
		Warning = 2,
		Notice  = 4,
		Traffic = 8,
		Debug   = 16,
		All     = 31
	};

	public enum class CecLogicalAddress
	{
		Unknown          = -1, //not a valid logical address
		Tv               = 0,
		RecordingDevice1 = 1,
		RecordingDevice2 = 2,
		Tuner1           = 3,
		PlaybackDevice1  = 4,
		AudioSystem      = 5,
		Tuner2           = 6,
		Tuner3           = 7,
		PlaybackDevice2  = 8,
		RecordingDevice3 = 9,
		Tuner4           = 10,
		PlaybackDevice3  = 11,
		Reserved1        = 12,
		Reserved2        = 13,
		FreeUse          = 14,
		Unregistered     = 15,
		Broadcast        = 15
	};

	public enum class CecPowerStatus
	{
		On                      = 0x00,
		Standby                 = 0x01,
		InTransitionStandbyToOn = 0x02,
		InTransitionOnToStandby = 0x03,
		Unknown                 = 0x99
	};

	public enum class CecVersion
	{
		Unknown = 0x00,
		V1_2    = 0x01,
		V1_2A   = 0x02,
		V1_3    = 0x03,
		V1_3A   = 0x04,
		V1_4    = 0x05
	};

	public enum class CecDisplayControl
	{
		DisplayForDefaultTime = 0x00,
		DisplayUntilCleared   = 0x40,
		ClearPreviousMessage  = 0x80,
		ReservedForFutureUse  = 0xC0
	};

	public enum class CecMenuState
	{
		Activated   = 0,
		Deactivated = 1
	};

	public enum class CecDeckControlMode
	{
		SkipForwardWind   = 1,
		SkipReverseRewind = 2,
		Stop              = 3,
		Eject             = 4
	};

	public enum class CecDeckInfo
	{
		Play               = 0x11,
		Record             = 0x12,
		Reverse            = 0x13,
		Still              = 0x14,
		Slow               = 0x15,
		SlowReverse        = 0x16,
		FastForward        = 0x17,
		FastReverse        = 0x18,
		NoMedia            = 0x19,
		Stop               = 0x1A,
		SkipForwardWind    = 0x1B,
		SkipReverseRewind  = 0x1C,
		IndexSearchForward = 0x1D,
		IndexSearchReverse = 0x1E,
		OtherStatus        = 0x1F
	};

	public enum class CecUserControlCode
	{
		Select                      = 0x00,
		Up                          = 0x01,
		Down                        = 0x02,
		Left                        = 0x03,
		Right                       = 0x04,
		RightUp                     = 0x05,
		RightDown                   = 0x06,
		LeftUp                      = 0x07,
		LeftDown                    = 0x08,
		RootMenu                    = 0x09,
		SetupMenu                   = 0x0A,
		ContentsMenu                = 0x0B,
		FavoriteMenu                = 0x0C,
		Exit                        = 0x0D,
		Number0                     = 0x20,
		Number1                     = 0x21,
		Number2                     = 0x22,
		Number3                     = 0x23,
		Number4                     = 0x24,
		Number5                     = 0x25,
		Number6                     = 0x26,
		Number7                     = 0x27,
		Number8                     = 0x28,
		Number9                     = 0x29,
		Dot                         = 0x2A,
		Enter                       = 0x2B,
		Clear                       = 0x2C,
		NextFavorite                = 0x2F,
		ChannelUp                   = 0x30,
		ChannelDown                 = 0x31,
		PreviousChannel             = 0x32,
		SoundSelect                 = 0x33,
		InputSelect                 = 0x34,
		DisplayInformation          = 0x35,
		Help                        = 0x36,
		PageUp                      = 0x37,
		PageDown                    = 0x38,
		Power                       = 0x40,
		VolumeUp                    = 0x41,
		VolumeDown                  = 0x42,
		Mute                        = 0x43,
		Play                        = 0x44,
		Stop                        = 0x45,
		Pause                       = 0x46,
		Record                      = 0x47,
		Rewind                      = 0x48,
		FastForward                 = 0x49,
		Eject                       = 0x4A,
		Forward                     = 0x4B,
		Backward                    = 0x4C,
		StopRecord                  = 0x4D,
		PauseRecord                 = 0x4E,
		Angle                       = 0x50,
		SubPicture                  = 0x51,
		VideoOnDemand               = 0x52,
		ElectronicProgramGuide      = 0x53,
		TimerProgramming            = 0x54,
		InitialConfiguration        = 0x55,
		PlayFunction                = 0x60,
		PausePlayFunction           = 0x61,
		RecordFunction              = 0x62,
		PauseRecordFunction         = 0x63,
		StopFunction                = 0x64,
		MuteFunction                = 0x65,
		RestoreVolumeFunction       = 0x66,
		TuneFunction                = 0x67,
		SelectMediaFunction         = 0x68,
		SelectAVInputFunction       = 0x69,
		SelectAudioInputFunction    = 0x6A,
		PowerToggleFunction         = 0x6B,
		PowerOffFunction            = 0x6C,
		PowerOnFunction             = 0x6D,
		F1Blue                      = 0x71,
		F2Red                       = 0X72,
		F3Green                     = 0x73,
		F4Yellow                    = 0x74,
		F5                          = 0x75,
		Data                        = 0x76,
		Max                         = 0x76,
		Unknown
	};

	public enum class CecVendorId
	{
		Samsung   = 0x00F0,
		LG        = 0xE091,
		Panasonic = 0x8045,
		Pioneer   = 0xE036,
		Onkyo     = 0x09B0,
		Yamaha    = 0xA0DE,
		Philips   = 0x903E,
		Unknown   = 0
	};

	public enum class CecAudioStatus
	{
		MuteStatusMask      = 0x80,
		VolumeStatusMask    = 0x7F,
		VolumeMin           = 0x00,
		VolumeMax           = 0x64,
		VolumeStatusUnknown = 0x7F
	};

	public enum class CecOpcode
	{
		ActiveSource                  = 0x82,
		ImageViewOn                   = 0x04,
		TextViewOn                    = 0x0D,
		InactiveSource                = 0x9D,
		RequestActiveSource           = 0x85,
		RoutingChange                 = 0x80,
		RoutingInformation            = 0x81,
		SetStreamPath                 = 0x86,
		Standby                       = 0x36,
		RecordOff                     = 0x0B,
		RecordOn                      = 0x09,
		RecordStatus                  = 0x0A,
		RecordTvScreen                = 0x0F,
		ClearAnalogueTimer            = 0x33,
		ClearDigitalTimer             = 0x99,
		ClearExternalTimer            = 0xA1,
		SetAnalogueTimer              = 0x34,
		SetDigitalTimer               = 0x97,
		SetExternalTimer              = 0xA2,
		SetTimerProgramTitle          = 0x67,
		TimerClearedStatus            = 0x43,
		TimerStatus                   = 0x35,
		CecVersion                    = 0x9E,
		GetCecVersion                 = 0x9F,
		GivePhysicalAddress           = 0x83,
		GetMenuLanguage               = 0x91,
		ReportPhysicalAddress         = 0x84,
		SetMenuLanguage               = 0x32,
		DeckControl                   = 0x42,
		DeckStatus                    = 0x1B,
		GiveDeckStatus                = 0x1A,
		Play                          = 0x41,
		GiveTunerDeviceStatus         = 0x08,
		SelectAnalogueService         = 0x92,
		SelectDigtalService           = 0x93,
		TunerDeviceStatus             = 0x07,
		TunerStepDecrement            = 0x06,
		TunerStepIncrement            = 0x05,
		DeviceVendorId                = 0x87,
		GiveDeviceVendorId            = 0x8C,
		VendorCommand                 = 0x89,
		VendorCommandWithId           = 0xA0,
		VendorRemoteButtonDown        = 0x8A,
		VendorRemoteButtonUp          = 0x8B,
		SetOsdString                  = 0x64,
		GiveOsdName                   = 0x46,
		SetOsdName                    = 0x47,
		MenuRequest                   = 0x8D,
		MenuStatus                    = 0x8E,
		UserControlPressed            = 0x44,
		UserControlRelease            = 0x45,
		GiveDevicePowerStatus         = 0x8F,
		ReportPowerStatus             = 0x90,
		FeatureAbort                  = 0x00,
		Abort                         = 0xFF,
		GiveAudioStatus               = 0x71,
		GiveSystemAudioMode           = 0x7D,
		ReportAudioStatus             = 0x7A,
		SetSystemAudioMode            = 0x72,
		SystemAudioModeRequest        = 0x70,
		SystemAudioModeStatus         = 0x7E,
		SetAudioRate                  = 0x9A,
		/* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */
		None                          = 0xFD
	};

	public enum class CecSystemAudioStatus
	{
		Off = 0,
		On  = 1
	};

	public enum class CecClientVersion
	{
		VersionPre1_5 = 0,
		Version1_5_0  = 1
	};

	public ref class CecAdapter
	{
	public:
		CecAdapter(System::String ^ strPath, System::String ^ strComPort)
		{
			Path = strPath;
			ComPort = strComPort;
		}

		property System::String ^ Path;
		property System::String ^ ComPort;
	};

	public ref class CecDeviceTypeList
	{
	public:
		CecDeviceTypeList(void)
		{
			Types = gcnew array<CecDeviceType>(5);
			for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
				Types[iPtr] = CecDeviceType::Reserved;
		}

		property array<CecDeviceType> ^ Types;
	};

	public ref class CecLogicalAddresses
	{
	public:
		CecLogicalAddresses(void)
		{
			Addresses = gcnew array<CecLogicalAddress>(16);
			for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
				Addresses[iPtr] = CecLogicalAddress::Unregistered;
		}

		bool IsSet(CecLogicalAddress iAddress)
		{
			return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unregistered;
		}

		property array<CecLogicalAddress> ^ Addresses;
	};

	public ref class CecDatapacket
	{
	public:
		CecDatapacket(void)
		{
			Data = gcnew array<uint8_t>(100);
			Size = 0;
		}

		void PushBack(uint8_t data)
		{
			if (Size < 100)
			{
				Data[Size] = data;
				Size++;
			}
		}

		property array<uint8_t> ^ Data;
		property uint8_t          Size;
	};

	public ref class CecCommand
	{
	public:
		CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
		{
			Initiator       = iInitiator;
			Destination     = iDestination;
			Ack             = bAck;
			Eom             = bEom;
			Opcode          = iOpcode;
			OpcodeSet       = true;
			TransmitTimeout = iTransmitTimeout;
			Parameters      = gcnew CecDatapacket;
			Empty           = false;
		}

		CecCommand(void)
		{
			Initiator       = CecLogicalAddress::Unknown;
			Destination     = CecLogicalAddress::Unknown;
			Ack             = false;
			Eom             = false;
			Opcode          = CecOpcode::None;
			OpcodeSet       = false;
			TransmitTimeout = 0;
			Parameters      = gcnew CecDatapacket;
			Empty           = true;
		}

		void PushBack(uint8_t data)
		{
			if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
			{
				Initiator   = (CecLogicalAddress) (data >> 4);
				Destination = (CecLogicalAddress) (data & 0xF);
			}
			else if (!OpcodeSet)
			{
				OpcodeSet = true;
				Opcode    = (CecOpcode)data;
			}
			else
			{
				Parameters->PushBack(data);
			}
		}

		property bool               Empty;
		property CecLogicalAddress  Initiator;
		property CecLogicalAddress  Destination;
		property bool               Ack;
		property bool               Eom;
		property CecOpcode          Opcode;
		property CecDatapacket ^    Parameters;
		property bool               OpcodeSet;
		property int32_t            TransmitTimeout;
	};

	public ref class CecKeypress
	{
	public:
		CecKeypress(int iKeycode, unsigned int iDuration)
		{
			Keycode  = iKeycode;
			Duration = iDuration;
			Empty    = false;
		}

		CecKeypress(void)
		{
			Keycode  = 0;
			Duration = 0;
			Empty    = true;
		}

		property bool         Empty;
		property int          Keycode;
		property unsigned int Duration;
	};

	public ref class CecLogMessage
	{
	public:
		CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
		{
			Message = strMessage;
			Level   = iLevel;
			Time    = iTime;
			Empty   = false;
		}

		CecLogMessage(void)
		{
			Message = "";
			Level   = CecLogLevel::None;
			Time    = 0;
			Empty   = true;
		}

		property bool            Empty;
		property System::String ^Message;
		property CecLogLevel     Level;
		property int64_t         Time;
	};

	// the callback methods are called by unmanaged code, so we need some delegates for this
	#pragma unmanaged
	// unmanaged callback methods
	typedef int (__stdcall *LOGCB)    (const CEC::cec_log_message &message);
	typedef int (__stdcall *KEYCB)    (const CEC::cec_keypress &key);
	typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);

	static LOGCB              g_logCB;
	static KEYCB              g_keyCB;
	static COMMANDCB          g_commandCB;
	static CEC::ICECCallbacks g_cecCallbacks;

	int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
	{
		if (g_logCB)
			return g_logCB(message);
		return 0;
	}

	int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
	{
		if (g_keyCB)
			return g_keyCB(key);
		return 0;
	}

	int CecCommandCB(void *cbParam, const CEC::cec_command &command)
	{
		if (g_commandCB)
			return g_commandCB(command);
		return 0;
	}

	#pragma managed
	// delegates for the unmanaged callback methods
	public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
	public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
	public delegate int CecCommandManagedDelegate(const CEC::cec_command &);

	// callback method interface
	public ref class CecCallbackMethods
	{
	public:
		CecCallbackMethods(void)
		{
			m_bHasCallbacks = false;
			msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();

			// create the delegate method for the log message callback
			m_logMessageDelegate           = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
			m_logMessageGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
			g_logCB                        = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
			g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;

			// create the delegate method for the keypress callback
			m_keypressDelegate           = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
			m_keypressGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
			g_keyCB                      = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
			g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;

			// create the delegate method for the command callback
			m_commandDelegate           = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
			m_commandGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
			g_commandCB                 = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
			g_cecCallbacks.CBCecCommand = CecCommandCB;

			delete context;
		}

	~CecCallbackMethods(void)
   {
     DestroyDelegates();
   }

	protected:
   !CecCallbackMethods(void)
   {
     DestroyDelegates();
   }

	public:
		virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
		{
			if (!m_bHasCallbacks)
			{
				m_bHasCallbacks = true;
				m_callbacks = callbacks;
				return true;
			}

			return false;
		}

		virtual int ReceiveLogMessage(CecLogMessage ^ message)
		{
			return 0;
		}

		virtual int ReceiveKeypress(CecKeypress ^ key)
		{
			return 0;
		}

		virtual int ReceiveCommand(CecCommand ^ command)
		{
			return 0;
		}

	protected:
		// managed callback methods
		int CecLogMessageManaged(const CEC::cec_log_message &message)
		{
			int iReturn(0);
			if (m_bHasCallbacks)
				iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
			return iReturn;
		}

		int CecKeyPressManaged(const CEC::cec_keypress &key)
		{
			int iReturn(0);
			if (m_bHasCallbacks)
				iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
			return iReturn;
		}

		int CecCommandManaged(const CEC::cec_command &command)
		{
			int iReturn(0);
			if (m_bHasCallbacks)
			{
				CecCommand ^ newCommand = gcnew CecCommand((CecLogicalAddress)command.initiator, (CecLogicalAddress)command.destination, command.ack == 1 ? true : false, command.eom == 1 ? true : false, (CecOpcode)command.opcode, command.transmit_timeout);
				for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
					newCommand->Parameters->PushBack(command.parameters[iPtr]);
				iReturn = m_callbacks->ReceiveCommand(newCommand);
			}
			return iReturn;
		}

		void DestroyDelegates()
		{
			m_bHasCallbacks = false;
			delete m_callbacks;
			m_logMessageGCHandle.Free();
			m_keypressGCHandle.Free();
			m_commandGCHandle.Free();
		}

		CecLogMessageManagedDelegate ^                    m_logMessageDelegate;
		static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
		LOGCB                                             m_logMessageCallback;

		CecKeyPressManagedDelegate ^                      m_keypressDelegate;
		static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
		KEYCB                                             m_keypressCallback;

		CecCommandManagedDelegate ^                       m_commandDelegate;
		static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
		COMMANDCB                                         m_commandCallback;

		CecCallbackMethods ^ m_callbacks;
	  bool                 m_bHasCallbacks;
	};

	public ref class LibCECConfiguration
	{
	public:
		LibCECConfiguration(CecCallbackMethods ^callbacks)
		{
			DeviceName          = "";
			PhysicalAddress     = CEC_DEFAULT_PHYSICAL_ADDRESS;
			BaseDevice          = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
			HDMIPort            = CEC_DEFAULT_HDMI_PORT;
			ClientVersion       = CecClientVersion::VersionPre1_5;

			GetSettingsFromROM  = false;
			UseTVMenuLanguage   = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE ? true : false;
			PowerOnStartup      = CEC_DEFAULT_SETTING_POWER_ON_STARTUP ? true : false;
			PowerOffShutdown    = CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN ? true : false;
			PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER ? true : false;
			PowerOffOnStandby   = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY ? true : false;

			Callbacks           = callbacks;
		}

		property System::String ^    DeviceName;
		property CecDeviceTypeList ^ DeviceTypes;
		property uint16_t            PhysicalAddress;
		property CecLogicalAddress   BaseDevice;
		property uint8_t             HDMIPort;
		property CecClientVersion    ClientVersion;

		// player specific settings
		property bool                GetSettingsFromROM;
		property bool                UseTVMenuLanguage;
		property bool                PowerOnStartup;
		property bool                PowerOffShutdown;
		property bool                PowerOffScreensaver;
		property bool                PowerOffOnStandby;

		property CecCallbackMethods ^Callbacks;
	};
}
Commit	Line	Data
4ef3b314 LOK	1	#pragma once
	2	/*
	3	* This file is part of the libCEC(R) library.
	4	*
	5	* libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
	6	* libCEC(R) is an original work, containing original code.
	7	*
	8	* libCEC(R) is a trademark of Pulse-Eight Limited.
	9	*
	10	* This program is dual-licensed; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23	*
	24	*
	25	* Alternatively, you can license this library under a commercial license,
	26	* please contact Pulse-Eight Licensing for more information.
	27	*
	28	* For more information contact:
	29	* Pulse-Eight Licensing <license@pulse-eight.com>
	30	* http://www.pulse-eight.com/
	31	* http://www.pulse-eight.net/
	32	*/
	33
	34	#include <windows.h>
	35	#include <vcclr.h>
	36	#include <msclr/marshal.h>
	37	#include "../../include/cec.h"
	38
	39	#using <System.dll>
	40
	41	namespace CecSharp
	42	{
	43	public enum class CecDeviceType
	44	{
	45	Tv = 0,
	46	RecordingDevice = 1,
	47	Reserved = 2,
	48	Tuner = 3,
	49	PlaybackDevice = 4,
	50	AudioSystem = 5
	51	};
	52
	53	public enum class CecLogLevel
	54	{
	55	None = 0,
	56	Error = 1,
	57	Warning = 2,
	58	Notice = 4,
	59	Traffic = 8,
	60	Debug = 16,
	61	All = 31
	62	};
	63
	64	public enum class CecLogicalAddress
65	{
66	Unknown = -1, //not a valid logical address
67	Tv = 0,
68	RecordingDevice1 = 1,
69	RecordingDevice2 = 2,
70	Tuner1 = 3,
71	PlaybackDevice1 = 4,
72	AudioSystem = 5,
73	Tuner2 = 6,
74	Tuner3 = 7,
75	PlaybackDevice2 = 8,
76	RecordingDevice3 = 9,
77	Tuner4 = 10,
78	PlaybackDevice3 = 11,
79	Reserved1 = 12,
80	Reserved2 = 13,
81	FreeUse = 14,
82	Unregistered = 15,
83	Broadcast = 15
84	};
85
86	public enum class CecPowerStatus
87	{
88	On = 0x00,
89	Standby = 0x01,
90	InTransitionStandbyToOn = 0x02,
91	InTransitionOnToStandby = 0x03,
92	Unknown = 0x99
93	};
94
95	public enum class CecVersion
96	{
97	Unknown = 0x00,
98	V1_2 = 0x01,
99	V1_2A = 0x02,
100	V1_3 = 0x03,
101	V1_3A = 0x04,
102	V1_4 = 0x05
103	};
104
105	public enum class CecDisplayControl
106	{
107	DisplayForDefaultTime = 0x00,
108	DisplayUntilCleared = 0x40,
109	ClearPreviousMessage = 0x80,
110	ReservedForFutureUse = 0xC0
111	};
112
113	public enum class CecMenuState
114	{
115	Activated = 0,
116	Deactivated = 1
117	};
118
119	public enum class CecDeckControlMode
120	{
121	SkipForwardWind = 1,
122	SkipReverseRewind = 2,
123	Stop = 3,
124	Eject = 4
125	};
126
127	public enum class CecDeckInfo
128	{
129	Play = 0x11,
130	Record = 0x12,
131	Reverse = 0x13,
132	Still = 0x14,
133	Slow = 0x15,
134	SlowReverse = 0x16,
135	FastForward = 0x17,
136	FastReverse = 0x18,
137	NoMedia = 0x19,
138	Stop = 0x1A,
139	SkipForwardWind = 0x1B,
140	SkipReverseRewind = 0x1C,
141	IndexSearchForward = 0x1D,
142	IndexSearchReverse = 0x1E,
143	OtherStatus = 0x1F
144	};
145
146	public enum class CecUserControlCode
147	{
148	Select = 0x00,
149	Up = 0x01,
150	Down = 0x02,
151	Left = 0x03,
152	Right = 0x04,
153	RightUp = 0x05,
154	RightDown = 0x06,
155	LeftUp = 0x07,
156	LeftDown = 0x08,
157	RootMenu = 0x09,
158	SetupMenu = 0x0A,
159	ContentsMenu = 0x0B,
160	FavoriteMenu = 0x0C,
161	Exit = 0x0D,
162	Number0 = 0x20,
163	Number1 = 0x21,
164	Number2 = 0x22,
165	Number3 = 0x23,
166	Number4 = 0x24,
167	Number5 = 0x25,
168	Number6 = 0x26,
169	Number7 = 0x27,
170	Number8 = 0x28,
171	Number9 = 0x29,
172	Dot = 0x2A,
173	Enter = 0x2B,
174	Clear = 0x2C,
175	NextFavorite = 0x2F,
176	ChannelUp = 0x30,
177	ChannelDown = 0x31,
178	PreviousChannel = 0x32,
179	SoundSelect = 0x33,
180	InputSelect = 0x34,
181	DisplayInformation = 0x35,
182	Help = 0x36,
183	PageUp = 0x37,
184	PageDown = 0x38,
185	Power = 0x40,
186	VolumeUp = 0x41,
187	VolumeDown = 0x42,
188	Mute = 0x43,
189	Play = 0x44,
190	Stop = 0x45,
191	Pause = 0x46,
192	Record = 0x47,
193	Rewind = 0x48,
194	FastForward = 0x49,
195	Eject = 0x4A,
196	Forward = 0x4B,
197	Backward = 0x4C,
198	StopRecord = 0x4D,
199	PauseRecord = 0x4E,
200	Angle = 0x50,
201	SubPicture = 0x51,
202	VideoOnDemand = 0x52,
203	ElectronicProgramGuide = 0x53,
204	TimerProgramming = 0x54,
205	InitialConfiguration = 0x55,
206	PlayFunction = 0x60,
207	PausePlayFunction = 0x61,
208	RecordFunction = 0x62,
209	PauseRecordFunction = 0x63,
210	StopFunction = 0x64,
211	MuteFunction = 0x65,
212	RestoreVolumeFunction = 0x66,
213	TuneFunction = 0x67,
214	SelectMediaFunction = 0x68,
215	SelectAVInputFunction = 0x69,
216	SelectAudioInputFunction = 0x6A,
217	PowerToggleFunction = 0x6B,
218	PowerOffFunction = 0x6C,
219	PowerOnFunction = 0x6D,
220	F1Blue = 0x71,
221	F2Red = 0X72,
222	F3Green = 0x73,
223	F4Yellow = 0x74,
224	F5 = 0x75,
225	Data = 0x76,
226	Max = 0x76,
227	Unknown
228	};
229
230	public enum class CecVendorId
231	{
232	Samsung = 0x00F0,
233	LG = 0xE091,
234	Panasonic = 0x8045,
235	Pioneer = 0xE036,
236	Onkyo = 0x09B0,
237	Yamaha = 0xA0DE,
238	Philips = 0x903E,
239	Unknown = 0
240	};
241
242	public enum class CecAudioStatus
243	{
244	MuteStatusMask = 0x80,
245	VolumeStatusMask = 0x7F,
246	VolumeMin = 0x00,
247	VolumeMax = 0x64,
248	VolumeStatusUnknown = 0x7F
249	};
250
251	public enum class CecOpcode
252	{
253	ActiveSource = 0x82,
254	ImageViewOn = 0x04,
255	TextViewOn = 0x0D,
256	InactiveSource = 0x9D,
257	RequestActiveSource = 0x85,
258	RoutingChange = 0x80,
259	RoutingInformation = 0x81,
260	SetStreamPath = 0x86,
261	Standby = 0x36,
262	RecordOff = 0x0B,
263	RecordOn = 0x09,
264	RecordStatus = 0x0A,
265	RecordTvScreen = 0x0F,
266	ClearAnalogueTimer = 0x33,
267	ClearDigitalTimer = 0x99,
268	ClearExternalTimer = 0xA1,
269	SetAnalogueTimer = 0x34,
270	SetDigitalTimer = 0x97,
271	SetExternalTimer = 0xA2,
272	SetTimerProgramTitle = 0x67,
273	TimerClearedStatus = 0x43,
274	TimerStatus = 0x35,
275	CecVersion = 0x9E,
276	GetCecVersion = 0x9F,
277	GivePhysicalAddress = 0x83,
278	GetMenuLanguage = 0x91,
279	ReportPhysicalAddress = 0x84,
280	SetMenuLanguage = 0x32,
281	DeckControl = 0x42,
282	DeckStatus = 0x1B,
283	GiveDeckStatus = 0x1A,
284	Play = 0x41,
285	GiveTunerDeviceStatus = 0x08,
286	SelectAnalogueService = 0x92,
287	SelectDigtalService = 0x93,
288	TunerDeviceStatus = 0x07,
289	TunerStepDecrement = 0x06,
290	TunerStepIncrement = 0x05,
291	DeviceVendorId = 0x87,
292	GiveDeviceVendorId = 0x8C,
293	VendorCommand = 0x89,
294	VendorCommandWithId = 0xA0,
295	VendorRemoteButtonDown = 0x8A,
296	VendorRemoteButtonUp = 0x8B,
297	SetOsdString = 0x64,
298	GiveOsdName = 0x46,
299	SetOsdName = 0x47,
300	MenuRequest = 0x8D,
301	MenuStatus = 0x8E,
302	UserControlPressed = 0x44,
303	UserControlRelease = 0x45,
304	GiveDevicePowerStatus = 0x8F,
305	ReportPowerStatus = 0x90,
306	FeatureAbort = 0x00,
307	Abort = 0xFF,
308	GiveAudioStatus = 0x71,
309	GiveSystemAudioMode = 0x7D,
310	ReportAudioStatus = 0x7A,
311	SetSystemAudioMode = 0x72,
312	SystemAudioModeRequest = 0x70,
313	SystemAudioModeStatus = 0x7E,
314	SetAudioRate = 0x9A,
315	/* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */
316	None = 0xFD
317	};
318
319	public enum class CecSystemAudioStatus
320	{
321	Off = 0,
322	On = 1
323	};
324
325	public enum class CecClientVersion
326	{
327	VersionPre1_5 = 0,
328	Version1_5_0 = 1
329	};
330
331	public ref class CecAdapter
332	{
333	public:
334	CecAdapter(System::String ^ strPath, System::String ^ strComPort)
335	{
336	Path = strPath;
337	ComPort = strComPort;
338	}
339
340	property System::String ^ Path;
341	property System::String ^ ComPort;
342	};
343
344	public ref class CecDeviceTypeList
345	{
346	public:
347	CecDeviceTypeList(void)
348	{
349	Types = gcnew array<CecDeviceType>(5);
350	for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
351	Types[iPtr] = CecDeviceType::Reserved;
352	}
353
354	property array<CecDeviceType> ^ Types;
355	};
356
357	public ref class CecLogicalAddresses
358	{
359	public:
360	CecLogicalAddresses(void)
361	{
362	Addresses = gcnew array<CecLogicalAddress>(16);
363	for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
364	Addresses[iPtr] = CecLogicalAddress::Unregistered;
365	}
366
367	bool IsSet(CecLogicalAddress iAddress)
368	{
369	return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unregistered;
370	}
371
372	property array<CecLogicalAddress> ^ Addresses;
373	};
374
375	public ref class CecDatapacket
376	{
377	public:
378	CecDatapacket(void)
379	{
380	Data = gcnew array<uint8_t>(100);
381	Size = 0;
382	}
383
384	void PushBack(uint8_t data)
385	{
386	if (Size < 100)
387	{
388	Data[Size] = data;
389	Size++;
390	}
391	}
392
393	property array<uint8_t> ^ Data;
394	property uint8_t Size;
395	};
396
397	public ref class CecCommand
398	{
399	public:
400	CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
401	{
402	Initiator = iInitiator;
403	Destination = iDestination;
404	Ack = bAck;
405	Eom = bEom;
406	Opcode = iOpcode;
407	OpcodeSet = true;
408	TransmitTimeout = iTransmitTimeout;
409	Parameters = gcnew CecDatapacket;
410	Empty = false;
411	}
412
413	CecCommand(void)
414	{
415	Initiator = CecLogicalAddress::Unknown;
416	Destination = CecLogicalAddress::Unknown;
417	Ack = false;
418	Eom = false;
419	Opcode = CecOpcode::None;
420	OpcodeSet = false;
421	TransmitTimeout = 0;
422	Parameters = gcnew CecDatapacket;
423	Empty = true;
424	}
425
426	void PushBack(uint8_t data)
427	{
428	if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
429	{
430	Initiator = (CecLogicalAddress) (data >> 4);
431	Destination = (CecLogicalAddress) (data & 0xF);
432	}
433	else if (!OpcodeSet)
434	{
435	OpcodeSet = true;
436	Opcode = (CecOpcode)data;
437	}
438	else
439	{
440	Parameters->PushBack(data);
441	}
442	}
443
444	property bool Empty;
445	property CecLogicalAddress Initiator;
446	property CecLogicalAddress Destination;
447	property bool Ack;
448	property bool Eom;
449	property CecOpcode Opcode;
450	property CecDatapacket ^ Parameters;
451	property bool OpcodeSet;
452	property int32_t TransmitTimeout;
453	};
454
455	public ref class CecKeypress
456	{
457	public:
458	CecKeypress(int iKeycode, unsigned int iDuration)
459	{
460	Keycode = iKeycode;
461	Duration = iDuration;
462	Empty = false;
463	}
464
465	CecKeypress(void)
466	{
467	Keycode = 0;
468	Duration = 0;
469	Empty = true;
470	}
471
472	property bool Empty;
473	property int Keycode;
474	property unsigned int Duration;
475	};
476
477	public ref class CecLogMessage
478	{
479	public:
480	CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
481	{
482	Message = strMessage;
483	Level = iLevel;
484	Time = iTime;
485	Empty = false;
486	}
487
488	CecLogMessage(void)
489	{
490	Message = "";
491	Level = CecLogLevel::None;
492	Time = 0;
493	Empty = true;
494	}
495
496	property bool Empty;
497	property System::String ^Message;
498	property CecLogLevel Level;
499	property int64_t Time;
500	};
501
502	// the callback methods are called by unmanaged code, so we need some delegates for this
503	#pragma unmanaged
504	// unmanaged callback methods
505	typedef int (__stdcall *LOGCB) (const CEC::cec_log_message &message);
506	typedef int (__stdcall *KEYCB) (const CEC::cec_keypress &key);
507	typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
508
509	static LOGCB g_logCB;
510	static KEYCB g_keyCB;
511	static COMMANDCB g_commandCB;
512	static CEC::ICECCallbacks g_cecCallbacks;
513
514	int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
515	{
516	if (g_logCB)
517	return g_logCB(message);
518	return 0;
519	}
520
521	int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
522	{
523	if (g_keyCB)
524	return g_keyCB(key);
525	return 0;
526	}
527
528	int CecCommandCB(void *cbParam, const CEC::cec_command &command)
529	{
530	if (g_commandCB)
531	return g_commandCB(command);
532	return 0;
533	}
534
535	#pragma managed
536	// delegates for the unmanaged callback methods
537	public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
538	public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
539	public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
540
541	// callback method interface
542	public ref class CecCallbackMethods
543	{
544	public:
545	CecCallbackMethods(void)
546	{
547	m_bHasCallbacks = false;
548	msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
549
550	// create the delegate method for the log message callback
551	m_logMessageDelegate = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
552	m_logMessageGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
553	g_logCB = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
554	g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
555
556	// create the delegate method for the keypress callback
557	m_keypressDelegate = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
558	m_keypressGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
559	g_keyCB = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
560	g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
561
562	// create the delegate method for the command callback
563	m_commandDelegate = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
564	m_commandGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
565	g_commandCB = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
566	g_cecCallbacks.CBCecCommand = CecCommandCB;
567
568	delete context;
569	}
570
571	~CecCallbackMethods(void)
572	{
573	DestroyDelegates();
574	}
575
576	protected:
577	!CecCallbackMethods(void)
578	{
579	DestroyDelegates();
580	}
581
582	public:
583	virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
584	{
585	if (!m_bHasCallbacks)
586	{
587	m_bHasCallbacks = true;
588	m_callbacks = callbacks;
589	return true;
590	}
591
592	return false;
593	}
594
595	virtual int ReceiveLogMessage(CecLogMessage ^ message)
596	{
597	return 0;
598	}
599
600	virtual int ReceiveKeypress(CecKeypress ^ key)
601	{
602	return 0;
603	}
604
605	virtual int ReceiveCommand(CecCommand ^ command)
606	{
607	return 0;
608	}
609
610	protected:
611	// managed callback methods
612	int CecLogMessageManaged(const CEC::cec_log_message &message)
613	{
614	int iReturn(0);
615	if (m_bHasCallbacks)
616	iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
617	return iReturn;
618	}
619
620	int CecKeyPressManaged(const CEC::cec_keypress &key)
621	{
622	int iReturn(0);
623	if (m_bHasCallbacks)
624	iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
625	return iReturn;
626	}
627
628	int CecCommandManaged(const CEC::cec_command &command)
629	{
630	int iReturn(0);
631	if (m_bHasCallbacks)
632	{
633	CecCommand ^ newCommand = gcnew CecCommand((CecLogicalAddress)command.initiator, (CecLogicalAddress)command.destination, command.ack == 1 ? true : false, command.eom == 1 ? true : false, (CecOpcode)command.opcode, command.transmit_timeout);
634	for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
635	newCommand->Parameters->PushBack(command.parameters[iPtr]);
636	iReturn = m_callbacks->ReceiveCommand(newCommand);
637	}
638	return iReturn;
639	}
640
641	void DestroyDelegates()
642	{
643	m_bHasCallbacks = false;
644	delete m_callbacks;
645	m_logMessageGCHandle.Free();
646	m_keypressGCHandle.Free();
647	m_commandGCHandle.Free();
648	}
649
650	CecLogMessageManagedDelegate ^ m_logMessageDelegate;
651	static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
652	LOGCB m_logMessageCallback;
653
654	CecKeyPressManagedDelegate ^ m_keypressDelegate;
655	static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
656	KEYCB m_keypressCallback;
657
658	CecCommandManagedDelegate ^ m_commandDelegate;
659	static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
660	COMMANDCB m_commandCallback;
661
662	CecCallbackMethods ^ m_callbacks;
663	bool m_bHasCallbacks;
664	};
665
666	public ref class LibCECConfiguration
667	{
668	public:
669	LibCECConfiguration(CecCallbackMethods ^callbacks)
670	{
671	DeviceName = "";
672	PhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
673	BaseDevice = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
674	HDMIPort = CEC_DEFAULT_HDMI_PORT;
675	ClientVersion = CecClientVersion::VersionPre1_5;
676
677	GetSettingsFromROM = false;
678	UseTVMenuLanguage = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE ? true : false;
679	PowerOnStartup = CEC_DEFAULT_SETTING_POWER_ON_STARTUP ? true : false;
680	PowerOffShutdown = CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN ? true : false;
681	PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER ? true : false;
682	PowerOffOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY ? true : false;
683
684	Callbacks = callbacks;
685	}
686
687	property System::String ^ DeviceName;
688	property CecDeviceTypeList ^ DeviceTypes;
689	property uint16_t PhysicalAddress;
690	property CecLogicalAddress BaseDevice;
691	property uint8_t HDMIPort;
692	property CecClientVersion ClientVersion;
693
694	// player specific settings
695	property bool GetSettingsFromROM;
696	property bool UseTVMenuLanguage;
697	property bool PowerOnStartup;
698	property bool PowerOffShutdown;
699	property bool PowerOffScreensaver;
700	property bool PowerOffOnStandby;
701
702	property CecCallbackMethods ^Callbacks;
703	};
704	}