[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 CecLogicalAddress          Primary;
		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()
		{
			if (m_bHasCallbacks)
			{
				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(void)
		{
			DeviceName          = "";
			DeviceTypes         = gcnew CecDeviceTypeList();
			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 == 1;
			PowerOnStartup      = CEC_DEFAULT_SETTING_POWER_ON_STARTUP == 1;
			PowerOffShutdown    = CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1;
			PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
			PowerOffOnStandby   = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
		}

		void SetCallbacks(CecCallbackMethods ^callbacks)
		{
			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
a9fb46b4	372	property CecLogicalAddress Primary;
4ef3b314 LOK	373	property array<CecLogicalAddress> ^ Addresses;
	374	};
	375
	376	public ref class CecDatapacket
	377	{
	378	public:
	379	CecDatapacket(void)
	380	{
	381	Data = gcnew array<uint8_t>(100);
	382	Size = 0;
	383	}
	384
	385	void PushBack(uint8_t data)
	386	{
	387	if (Size < 100)
	388	{
	389	Data[Size] = data;
	390	Size++;
	391	}
	392	}
	393
	394	property array<uint8_t> ^ Data;
	395	property uint8_t Size;
	396	};
	397
	398	public ref class CecCommand
	399	{
	400	public:
	401	CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
	402	{
	403	Initiator = iInitiator;
	404	Destination = iDestination;
	405	Ack = bAck;
	406	Eom = bEom;
	407	Opcode = iOpcode;
	408	OpcodeSet = true;
	409	TransmitTimeout = iTransmitTimeout;
	410	Parameters = gcnew CecDatapacket;
	411	Empty = false;
	412	}
	413
	414	CecCommand(void)
	415	{
	416	Initiator = CecLogicalAddress::Unknown;
	417	Destination = CecLogicalAddress::Unknown;
	418	Ack = false;
	419	Eom = false;
	420	Opcode = CecOpcode::None;
	421	OpcodeSet = false;
	422	TransmitTimeout = 0;
	423	Parameters = gcnew CecDatapacket;
	424	Empty = true;
	425	}
	426
	427	void PushBack(uint8_t data)
	428	{
	429	if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
	430	{
	431	Initiator = (CecLogicalAddress) (data >> 4);
	432	Destination = (CecLogicalAddress) (data & 0xF);
	433	}
	434	else if (!OpcodeSet)
	435	{
	436	OpcodeSet = true;
437	Opcode = (CecOpcode)data;
438	}
439	else
440	{
441	Parameters->PushBack(data);
442	}
443	}
444
445	property bool Empty;
446	property CecLogicalAddress Initiator;
447	property CecLogicalAddress Destination;
448	property bool Ack;
449	property bool Eom;
450	property CecOpcode Opcode;
451	property CecDatapacket ^ Parameters;
452	property bool OpcodeSet;
453	property int32_t TransmitTimeout;
454	};
455
456	public ref class CecKeypress
457	{
458	public:
459	CecKeypress(int iKeycode, unsigned int iDuration)
460	{
461	Keycode = iKeycode;
462	Duration = iDuration;
463	Empty = false;
464	}
465
466	CecKeypress(void)
467	{
468	Keycode = 0;
469	Duration = 0;
470	Empty = true;
471	}
472
473	property bool Empty;
474	property int Keycode;
475	property unsigned int Duration;
476	};
477
478	public ref class CecLogMessage
479	{
480	public:
481	CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
482	{
483	Message = strMessage;
484	Level = iLevel;
485	Time = iTime;
486	Empty = false;
487	}
488
489	CecLogMessage(void)
490	{
491	Message = "";
492	Level = CecLogLevel::None;
493	Time = 0;
494	Empty = true;
495	}
496
497	property bool Empty;
498	property System::String ^Message;
499	property CecLogLevel Level;
500	property int64_t Time;
501	};
502
503	// the callback methods are called by unmanaged code, so we need some delegates for this
504	#pragma unmanaged
505	// unmanaged callback methods
506	typedef int (__stdcall *LOGCB) (const CEC::cec_log_message &message);
507	typedef int (__stdcall *KEYCB) (const CEC::cec_keypress &key);
508	typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
509
510	static LOGCB g_logCB;
511	static KEYCB g_keyCB;
512	static COMMANDCB g_commandCB;
513	static CEC::ICECCallbacks g_cecCallbacks;
514
515	int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
516	{
517	if (g_logCB)
518	return g_logCB(message);
519	return 0;
520	}
521
522	int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
523	{
524	if (g_keyCB)
525	return g_keyCB(key);
526	return 0;
527	}
528
529	int CecCommandCB(void *cbParam, const CEC::cec_command &command)
530	{
531	if (g_commandCB)
532	return g_commandCB(command);
533	return 0;
534	}
535
536	#pragma managed
537	// delegates for the unmanaged callback methods
538	public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
539	public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
540	public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
541
542	// callback method interface
543	public ref class CecCallbackMethods
544	{
545	public:
546	CecCallbackMethods(void)
547	{
548	m_bHasCallbacks = false;
549	msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
550
551	// create the delegate method for the log message callback
552	m_logMessageDelegate = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
553	m_logMessageGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
554	g_logCB = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
555	g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
556
557	// create the delegate method for the keypress callback
558	m_keypressDelegate = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
559	m_keypressGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
560	g_keyCB = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
561	g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
562
563	// create the delegate method for the command callback
564	m_commandDelegate = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
565	m_commandGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
566	g_commandCB = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
567	g_cecCallbacks.CBCecCommand = CecCommandCB;
568
569	delete context;
570	}
571
572	~CecCallbackMethods(void)
573	{
574	DestroyDelegates();
575	}
576
577	protected:
578	!CecCallbackMethods(void)
579	{
580	DestroyDelegates();
581	}
582
583	public:
584	virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
585	{
586	if (!m_bHasCallbacks)
587	{
588	m_bHasCallbacks = true;
589	m_callbacks = callbacks;
590	return true;
591	}
592
593	return false;
594	}
595
596	virtual int ReceiveLogMessage(CecLogMessage ^ message)
597	{
598	return 0;
599	}
600
601	virtual int ReceiveKeypress(CecKeypress ^ key)
602	{
603	return 0;
604	}
605
606	virtual int ReceiveCommand(CecCommand ^ command)
607	{
608	return 0;
609	}
610
611	protected:
612	// managed callback methods
613	int CecLogMessageManaged(const CEC::cec_log_message &message)
614	{
615	int iReturn(0);
616	if (m_bHasCallbacks)
617	iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
618	return iReturn;
619	}
620
621	int CecKeyPressManaged(const CEC::cec_keypress &key)
622	{
623	int iReturn(0);
624	if (m_bHasCallbacks)
625	iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
626	return iReturn;
627	}
628
629	int CecCommandManaged(const CEC::cec_command &command)
630	{
631	int iReturn(0);
632	if (m_bHasCallbacks)
633	{
634	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);
635	for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
636	newCommand->Parameters->PushBack(command.parameters[iPtr]);
637	iReturn = m_callbacks->ReceiveCommand(newCommand);
638	}
639	return iReturn;
640	}
641
642	void DestroyDelegates()
643	{
006b76b9 LOK	644	if (m_bHasCallbacks)
	645	{
	646	m_bHasCallbacks = false;
	647	delete m_callbacks;
	648	m_logMessageGCHandle.Free();
	649	m_keypressGCHandle.Free();
	650	m_commandGCHandle.Free();
	651	}
4ef3b314 LOK	652	}
	653
	654	CecLogMessageManagedDelegate ^ m_logMessageDelegate;
	655	static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
	656	LOGCB m_logMessageCallback;
	657
	658	CecKeyPressManagedDelegate ^ m_keypressDelegate;
	659	static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
	660	KEYCB m_keypressCallback;
	661
	662	CecCommandManagedDelegate ^ m_commandDelegate;
	663	static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
	664	COMMANDCB m_commandCallback;
	665
	666	CecCallbackMethods ^ m_callbacks;
	667	bool m_bHasCallbacks;
	668	};
	669
	670	public ref class LibCECConfiguration
	671	{
	672	public:
41297a45	673	LibCECConfiguration(void)
4ef3b314 LOK	674	{
4ef3b314 LOK	675	DeviceName = "";
d93fd396	676	DeviceTypes = gcnew CecDeviceTypeList();
4ef3b314 LOK	677	PhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
	678	BaseDevice = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
	679	HDMIPort = CEC_DEFAULT_HDMI_PORT;
	680	ClientVersion = CecClientVersion::VersionPre1_5;
	681
	682	GetSettingsFromROM = false;
006b76b9 LOK	683	UseTVMenuLanguage = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE == 1;
	684	PowerOnStartup = CEC_DEFAULT_SETTING_POWER_ON_STARTUP == 1;
	685	PowerOffShutdown = CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1;
	686	PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
	687	PowerOffOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
41297a45	688	}
4ef3b314	689
41297a45 LOK	690	void SetCallbacks(CecCallbackMethods ^callbacks)
	691	{
	692	Callbacks = callbacks;
4ef3b314 LOK	693	}
	694
	695	property System::String ^ DeviceName;
	696	property CecDeviceTypeList ^ DeviceTypes;
	697	property uint16_t PhysicalAddress;
	698	property CecLogicalAddress BaseDevice;
	699	property uint8_t HDMIPort;
	700	property CecClientVersion ClientVersion;
	701
	702	// player specific settings
	703	property bool GetSettingsFromROM;
	704	property bool UseTVMenuLanguage;
	705	property bool PowerOnStartup;
	706	property bool PowerOffShutdown;
	707	property bool PowerOffScreensaver;
	708	property bool PowerOffOnStandby;
	709
	710	property CecCallbackMethods ^Callbacks;
	711	};
	712	}