src/LibCecSharp/LibCecSharp.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited.  All rights reserved.
   5  * libCEC(R) is an original work, containing original code.
   6  *
   7  * libCEC(R) is a trademark of Pulse-Eight Limited.
   8  *
   9  * This program is dual-licensed; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  *
  23  *
  24  * Alternatively, you can license this library under a commercial license,
  25  * please contact Pulse-Eight Licensing for more information.
  26  *
  27  * For more information contact:
  28  * Pulse-Eight Licensing       <license@pulse-eight.com>
  29  *     http://www.pulse-eight.com/
  30  *     http://www.pulse-eight.net/
  31  */
  32
  33 #include <windows.h>
  34 #include <vcclr.h>
  35 #include <msclr/marshal.h>
  36 #include <cec.h>
  37 #using <System.dll>
  38
  39 using namespace System;
  40 using namespace System::Runtime::InteropServices;
  41 using namespace CEC;
  42 using namespace msclr::interop;
  43
  44 public enum class CecDeviceType
  45 {
  46   Tv              = 0,
  47   RecordingDevice = 1,
  48   Reserved        = 2,
  49   Tuner           = 3,
  50   PlaybackDevice  = 4,
  51   AudioSystem     = 5
  52 };
  53
  54 public enum class CecLogLevel
  55 {
  56   None    = 0,
  57   Error   = 1,
  58   Warning = 2,
  59   Notice  = 4,
  60   Traffic = 8,
  61   Debug   = 16,
  62   All     = 31
  63 };
  64
  65 public enum class CecLogicalAddress
  66 {
  67   Unknown          = -1, //not a valid logical address
  68   Tv               = 0,
  69   RecordingDevice1 = 1,
  70   RecordingDevice2 = 2,
  71   Tuner1           = 3,
  72   PlaybackDevice1  = 4,
  73   AudioSystem      = 5,
  74   Tuner2           = 6,
  75   Tuner3           = 7,
  76   PlaybackDevice2  = 8,
  77   RecordingDevice3 = 9,
  78   Tuner4           = 10,
  79   PlaybackDevice3  = 11,
  80   Reserved1        = 12,
  81   Reserved2        = 13,
  82   FreeUse          = 14,
  83   Unregistered     = 15,
  84   Broadcast        = 15
  85 };
  86
  87 public enum class CecPowerStatus
  88 {
  89   On                      = 0x00,
  90   Standby                 = 0x01,
  91   InTransitionStandbyToOn = 0x02,
  92   InTransitionOnToStandby = 0x03,
  93   Unknown                 = 0x99
  94 };
  95
  96 public enum class CecVersion
  97 {
  98   Unknown = 0x00,
  99   V1_2    = 0x01,
 100   V1_2A   = 0x02,
 101   V1_3    = 0x03,
 102   V1_3A   = 0x04,
 103   V1_4    = 0x05
 104 };
 105
 106 public enum class CecDisplayControl
 107 {
 108   DisplayForDefaultTime = 0x00,
 109   DisplayUntilCleared   = 0x40,
 110   ClearPreviousMessage  = 0x80,
 111   ReservedForFutureUse  = 0xC0
 112 };
 113
 114 public enum class CecMenuState
 115 {
 116   Activated   = 0,
 117   Deactivated = 1
 118 };
 119
 120 public enum class CecDeckControlMode
 121 {
 122   SkipForwardWind   = 1,
 123   SkipReverseRewind = 2,
 124   Stop              = 3,
 125   Eject             = 4
 126 };
 127
 128 public enum class CecDeckInfo
 129 {
 130   Play               = 0x11,
 131   Record             = 0x12,
 132   Reverse            = 0x13,
 133   Still              = 0x14,
 134   Slow               = 0x15,
 135   SlowReverse        = 0x16,
 136   FastForward        = 0x17,
 137   FastReverse        = 0x18,
 138   NoMedia            = 0x19,
 139   Stop               = 0x1A,
 140   SkipForwardWind    = 0x1B,
 141   SkipReverseRewind  = 0x1C,
 142   IndexSearchForward = 0x1D,
 143   IndexSearchReverse = 0x1E,
 144   OtherStatus        = 0x1F
 145 };
 146
 147 public enum class CecUserControlCode
 148 {
 149   Select                      = 0x00,
 150   Up                          = 0x01,
 151   Down                        = 0x02,
 152   Left                        = 0x03,
 153   Right                       = 0x04,
 154   RightUp                     = 0x05,
 155   RightDown                   = 0x06,
 156   LeftUp                      = 0x07,
 157   LeftDown                    = 0x08,
 158   RootMenu                    = 0x09,
 159   SetupMenu                   = 0x0A,
 160   ContentsMenu                = 0x0B,
 161   FavoriteMenu                = 0x0C,
 162   Exit                        = 0x0D,
 163   Number0                     = 0x20,
 164   Number1                     = 0x21,
 165   Number2                     = 0x22,
 166   Number3                     = 0x23,
 167   Number4                     = 0x24,
 168   Number5                     = 0x25,
 169   Number6                     = 0x26,
 170   Number7                     = 0x27,
 171   Number8                     = 0x28,
 172   Number9                     = 0x29,
 173   Dot                         = 0x2A,
 174   Enter                       = 0x2B,
 175   Clear                       = 0x2C,
 176   NextFavorite                = 0x2F,
 177   ChannelUp                   = 0x30,
 178   ChannelDown                 = 0x31,
 179   PreviousChannel             = 0x32,
 180   SoundSelect                 = 0x33,
 181   InputSelect                 = 0x34,
 182   DisplayInformation          = 0x35,
 183   Help                        = 0x36,
 184   PageUp                      = 0x37,
 185   PageDown                    = 0x38,
 186   Power                       = 0x40,
 187   VolumeUp                    = 0x41,
 188   VolumeDown                  = 0x42,
 189   Mute                        = 0x43,
 190   Play                        = 0x44,
 191   Stop                        = 0x45,
 192   Pause                       = 0x46,
 193   Record                      = 0x47,
 194   Rewind                      = 0x48,
 195   FastForward                 = 0x49,
 196   Eject                       = 0x4A,
 197   Forward                     = 0x4B,
 198   Backward                    = 0x4C,
 199   StopRecord                  = 0x4D,
 200   PauseRecord                 = 0x4E,
 201   Angle                       = 0x50,
 202   SubPicture                  = 0x51,
 203   VideoOnDemand               = 0x52,
 204   ElectronicProgramGuide      = 0x53,
 205   TimerProgramming            = 0x54,
 206   InitialConfiguration        = 0x55,
 207   PlayFunction                = 0x60,
 208   PausePlayFunction           = 0x61,
 209   RecordFunction              = 0x62,
 210   PauseRecordFunction         = 0x63,
 211   StopFunction                = 0x64,
 212   MuteFunction                = 0x65,
 213   RestoreVolumeFunction       = 0x66,
 214   TuneFunction                = 0x67,
 215   SelectMediaFunction         = 0x68,
 216   SelectAVInputFunction       = 0x69,
 217   SelectAudioInputFunction    = 0x6A,
 218   PowerToggleFunction         = 0x6B,
 219   PowerOffFunction            = 0x6C,
 220   PowerOnFunction             = 0x6D,
 221   F1Blue                      = 0x71,
 222   F2Red                       = 0X72,
 223   F3Green                     = 0x73,
 224   F4Yellow                    = 0x74,
 225   F5                          = 0x75,
 226   Data                        = 0x76,
 227   Max                         = 0x76,
 228   Unknown
 229 };
 230
 231 public enum class CecVendorId
 232 {
 233   Samsung   = 0x00F0,
 234   LG        = 0xE091,
 235   Panasonic = 0x8045,
 236   Pioneer   = 0xE036,
 237   Onkyo     = 0x09B0,
 238   Yamaha    = 0xA0DE,
 239   Philips   = 0x903E,
 240   Unknown   = 0
 241 };
 242
 243 public enum class CecAudioStatus
 244 {
 245   MuteStatusMask      = 0x80,
 246   VolumeStatusMask    = 0x7F,
 247   VolumeMin           = 0x00,
 248   VolumeMax           = 0x64,
 249   VolumeStatusUnknown = 0x7F
 250 };
 251
 252 public enum class CecOpcode
 253 {
 254   ActiveSource                  = 0x82,
 255   ImageViewOn                   = 0x04,
 256   TextViewOn                    = 0x0D,
 257   InactiveSource                = 0x9D,
 258   RequestActiveSource           = 0x85,
 259   RoutingChange                 = 0x80,
 260   RoutingInformation            = 0x81,
 261   SetStreamPath                 = 0x86,
 262   Standby                       = 0x36,
 263   RecordOff                     = 0x0B,
 264   RecordOn                      = 0x09,
 265   RecordStatus                  = 0x0A,
 266   RecordTvScreen                = 0x0F,
 267   ClearAnalogueTimer            = 0x33,
 268   ClearDigitalTimer             = 0x99,
 269   ClearExternalTimer            = 0xA1,
 270   SetAnalogueTimer              = 0x34,
 271   SetDigitalTimer               = 0x97,
 272   SetExternalTimer              = 0xA2,
 273   SetTimerProgramTitle          = 0x67,
 274   TimerClearedStatus            = 0x43,
 275   TimerStatus                   = 0x35,
 276   CecVersion                    = 0x9E,
 277   GetCecVersion                 = 0x9F,
 278   GivePhysicalAddress           = 0x83,
 279   GetMenuLanguage               = 0x91,
 280   ReportPhysicalAddress         = 0x84,
 281   SetMenuLanguage               = 0x32,
 282   DeckControl                   = 0x42,
 283   DeckStatus                    = 0x1B,
 284   GiveDeckStatus                = 0x1A,
 285   Play                          = 0x41,
 286   GiveTunerDeviceStatus         = 0x08,
 287   SelectAnalogueService         = 0x92,
 288   SelectDigtalService           = 0x93,
 289   TunerDeviceStatus             = 0x07,
 290   TunerStepDecrement            = 0x06,
 291   TunerStepIncrement            = 0x05,
 292   DeviceVendorId                = 0x87,
 293   GiveDeviceVendorId            = 0x8C,
 294   VendorCommand                 = 0x89,
 295   VendorCommandWithId           = 0xA0,
 296   VendorRemoteButtonDown        = 0x8A,
 297   VendorRemoteButtonUp          = 0x8B,
 298   SetOsdString                  = 0x64,
 299   GiveOsdName                   = 0x46,
 300   SetOsdName                    = 0x47,
 301   MenuRequest                   = 0x8D,
 302   MenuStatus                    = 0x8E,
 303   UserControlPressed            = 0x44,
 304   UserControlRelease            = 0x45,
 305   GiveDevicePowerStatus         = 0x8F,
 306   ReportPowerStatus             = 0x90,
 307   FeatureAbort                  = 0x00,
 308   Abort                         = 0xFF,
 309   GiveAudioStatus               = 0x71,
 310   GiveSystemAudioMode           = 0x7D,
 311   ReportAudioStatus             = 0x7A,
 312   SetSystemAudioMode            = 0x72,
 313   SystemAudioModeRequest        = 0x70,
 314   SystemAudioModeStatus         = 0x7E,
 315   SetAudioRate                  = 0x9A,
 316   /* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */
 317   None                          = 0xFD
 318 };
 319
 320 public enum class CecSystemAudioStatus
 321 {
 322   Off = 0,
 323   On  = 1
 324 };
 325
 326 public ref class CecAdapter
 327 {
 328 public:
 329   CecAdapter(String ^ strPath, String ^ strComPort)
 330   {
 331     Path = strPath;
 332     ComPort = strComPort;
 333   }
 334
 335   property String ^ Path;
 336   property String ^ ComPort;
 337 };
 338
 339 public ref class CecDeviceTypeList
 340 {
 341 public:
 342   CecDeviceTypeList(void)
 343   {
 344     Types = gcnew array<CecDeviceType>(5);
 345     for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 346       Types[iPtr] = CecDeviceType::Reserved;
 347   }
 348
 349   property array<CecDeviceType> ^ Types;
 350 };
 351
 352 public ref class CecLogicalAddresses
 353 {
 354 public:
 355   CecLogicalAddresses(void)
 356   {
 357     Addresses = gcnew array<CecLogicalAddress>(16);
 358     for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 359       Addresses[iPtr] = CecLogicalAddress::Unregistered;
 360   }
 361
 362   bool IsSet(CecLogicalAddress iAddress)
 363   {
 364     return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unregistered;
 365   }
 366
 367   property array<CecLogicalAddress> ^ Addresses;
 368 };
 369
 370 public ref class CecDatapacket
 371 {
 372 public:
 373   CecDatapacket(void)
 374   {
 375     Data = gcnew array<uint8_t>(100);
 376     Size = 0;
 377   }
 378
 379   void PushBack(uint8_t data)
 380   {
 381     if (Size < 100)
 382     {
 383       Data[Size] = data;
 384       Size++;
 385     }
 386   }
 387
 388   property array<uint8_t> ^ Data;
 389   property uint8_t          Size;
 390 };
 391
 392 public ref class CecCommand
 393 {
 394 public:
 395   CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
 396   {
 397     Initiator       = iInitiator;
 398     Destination     = iDestination;
 399     Ack             = bAck;
 400     Eom             = bEom;
 401     Opcode          = iOpcode;
 402     OpcodeSet       = true;
 403     TransmitTimeout = iTransmitTimeout;
 404     Parameters      = gcnew CecDatapacket;
 405     Empty           = false;
 406   }
 407
 408   CecCommand(void)
 409   {
 410     Initiator       = CecLogicalAddress::Unknown;
 411     Destination     = CecLogicalAddress::Unknown;
 412     Ack             = false;
 413     Eom             = false;
 414     Opcode          = CecOpcode::None;
 415     OpcodeSet       = false;
 416     TransmitTimeout = 0;
 417     Parameters      = gcnew CecDatapacket;
 418     Empty           = true;
 419   }
 420
 421   void PushBack(uint8_t data)
 422   {
 423     if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
 424     {
 425       Initiator   = (CecLogicalAddress) (data >> 4);
 426       Destination = (CecLogicalAddress) (data & 0xF);
 427     }
 428     else if (!OpcodeSet)
 429     {
 430       OpcodeSet = true;
 431       Opcode    = (CecOpcode)data;
 432     }
 433     else
 434     {
 435       Parameters->PushBack(data);
 436     }
 437   }
 438
 439   property bool               Empty;
 440   property CecLogicalAddress  Initiator;
 441   property CecLogicalAddress  Destination;
 442   property bool               Ack;
 443   property bool               Eom;
 444   property CecOpcode          Opcode;
 445   property CecDatapacket ^    Parameters;
 446   property bool               OpcodeSet;
 447   property int32_t            TransmitTimeout;
 448 };
 449
 450 public ref class CecKeypress
 451 {
 452 public:
 453   CecKeypress(int iKeycode, unsigned int iDuration)
 454   {
 455     Keycode  = iKeycode;
 456     Duration = iDuration;
 457     Empty    = false;
 458   }
 459
 460   CecKeypress(void)
 461   {
 462     Keycode  = 0;
 463     Duration = 0;
 464     Empty    = true;
 465   }
 466
 467   property bool         Empty;
 468   property int          Keycode;
 469   property unsigned int Duration;
 470 };
 471
 472 public ref class CecLogMessage
 473 {
 474 public:
 475   CecLogMessage(String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
 476   {
 477     Message = strMessage;
 478     Level   = iLevel;
 479     Time    = iTime;
 480     Empty   = false;
 481   }
 482
 483   CecLogMessage(void)
 484   {
 485     Message = "";
 486     Level   = CecLogLevel::None;
 487     Time    = 0;
 488     Empty   = true;
 489   }
 490
 491   property bool        Empty;
 492   property String ^    Message;
 493   property CecLogLevel Level;
 494   property int64_t     Time;
 495 };
 496
 497 public ref class CecCallbackMethods
 498 {
 499 public:
 500   virtual int ReceiveLogMessage(CecLogMessage ^ message)
 501   {
 502     return 0;
 503   }
 504
 505   virtual int ReceiveKeypress(CecKeypress ^ key)
 506   {
 507     return 0;
 508   }
 509
 510   virtual int ReceiveCommand(CecCommand ^ command)
 511   {
 512     return 0;
 513   }
 514 };
 515
 516 #pragma unmanaged
 517 // unmanaged callback methods
 518 typedef int (__stdcall *LOGCB)    (const cec_log_message &message);
 519 typedef int (__stdcall *KEYCB)    (const cec_keypress &key);
 520 typedef int (__stdcall *COMMANDCB)(const cec_command &command);
 521
 522 static LOGCB         g_logCB;
 523 static KEYCB         g_keyCB;
 524 static COMMANDCB     g_commandCB;
 525 static ICECCallbacks g_cecCallbacks;
 526
 527 int CecLogMessageCB(void *cbParam, const cec_log_message &message)
 528 {
 529   if (g_logCB)
 530     return g_logCB(message);
 531   return 0;
 532 }
 533
 534 int CecKeyPressCB(void *cbParam, const cec_keypress &key)
 535 {
 536   if (g_keyCB)
 537     return g_keyCB(key);
 538   return 0;
 539 }
 540
 541 int CecCommandCB(void *cbParam, const cec_command &command)
 542 {
 543   if (g_commandCB)
 544     return g_commandCB(command);
 545   return 0;
 546 }
 547
 548 #pragma managed
 549 // delegates for the unmanaged callback methods
 550 public delegate int CecLogMessageManagedDelegate(const cec_log_message &);
 551 public delegate int CecKeyPressManagedDelegate(const cec_keypress &);
 552 public delegate int CecCommandManagedDelegate(const cec_command &);
 553
 554 public ref class LibCecSharp
 555 {
 556 public:
 557   LibCecSharp(String ^ strDeviceName, CecDeviceTypeList ^ deviceTypes)
 558   {
 559     marshal_context ^ context = gcnew marshal_context();
 560     m_bHasCallbacks = false;
 561     const char* strDeviceNameC = context->marshal_as<const char*>(strDeviceName);
 562
 563     cec_device_type_list types;
 564     for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 565       types.types[iPtr] = (cec_device_type)deviceTypes->Types[iPtr];
 566     m_libCec = (ICECAdapter *) CECInit(strDeviceNameC, types);
 567
 568     // create the delegate method for the log message callback
 569     m_logMessageDelegate           = gcnew CecLogMessageManagedDelegate(this, &LibCecSharp::CecLogMessageManaged);
 570     m_logMessageGCHandle           = GCHandle::Alloc(m_logMessageDelegate);
 571     g_logCB                        = static_cast<LOGCB>(Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
 572     g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
 573
 574     // create the delegate method for the keypress callback
 575     m_keypressDelegate           = gcnew CecKeyPressManagedDelegate(this, &LibCecSharp::CecKeyPressManaged);
 576     m_keypressGCHandle           = GCHandle::Alloc(m_keypressDelegate);
 577     g_keyCB                      = static_cast<KEYCB>(Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
 578     g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
 579
 580     // create the delegate method for the command callback
 581     m_commandDelegate           = gcnew CecCommandManagedDelegate(this, &LibCecSharp::CecCommandManaged);
 582     m_commandGCHandle           = GCHandle::Alloc(m_commandDelegate);
 583     g_commandCB                 = static_cast<COMMANDCB>(Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
 584     g_cecCallbacks.CBCecCommand = CecCommandCB;
 585
 586     delete context;
 587   }
 588
 589    ~LibCecSharp(void)
 590    {
 591      CECDestroy(m_libCec);
 592      DestroyDelegates();
 593      m_libCec = NULL;
 594    }
 595
 596 protected:
 597    !LibCecSharp(void)
 598    {
 599      CECDestroy(m_libCec);
 600      DestroyDelegates();
 601      m_libCec = NULL;
 602    }
 603
 604 public:
 605   array<CecAdapter ^> ^ FindAdapters(String ^ path)
 606   {
 607     cec_adapter *devices = new cec_adapter[10];
 608
 609     marshal_context ^ context = gcnew marshal_context();
 610     const char* strPathC = path->Length > 0 ? context->marshal_as<const char*>(path) : NULL;
 611
 612     uint8_t iDevicesFound = m_libCec->FindAdapters(devices, 10, NULL);
 613
 614     array<CecAdapter ^> ^ adapters = gcnew array<CecAdapter ^>(iDevicesFound);
 615     for (unsigned int iPtr = 0; iPtr < iDevicesFound; iPtr++)
 616       adapters[iPtr] = gcnew CecAdapter(gcnew String(devices[iPtr].path), gcnew String(devices[iPtr].comm));
 617
 618     delete devices;
 619     delete context;
 620     return adapters;
 621   }
 622
 623   bool Open(String ^ strPort, int iTimeoutMs)
 624   {
 625     marshal_context ^ context = gcnew marshal_context();
 626     const char* strPortC = context->marshal_as<const char*>(strPort);
 627     bool bReturn = m_libCec->Open(strPortC, iTimeoutMs);
 628     delete context;
 629     return bReturn;
 630   }
 631
 632   void Close(void)
 633   {
 634     m_libCec->Close();
 635   }
 636
 637   bool EnableCallbacks(CecCallbackMethods ^ callbacks)
 638   {
 639     if (m_libCec && !m_bHasCallbacks)
 640     {
 641       m_bHasCallbacks = true;
 642       m_callbacks = callbacks;
 643       return m_libCec->EnableCallbacks(NULL, &g_cecCallbacks);
 644     }
 645
 646     return false;
 647   }
 648
 649   bool PingAdapter(void)
 650   {
 651     return m_libCec->PingAdapter();
 652   }
 653
 654   bool StartBootloader(void)
 655   {
 656     return m_libCec->StartBootloader();
 657   }
 658
 659   int GetMinLibVersion(void)
 660   {
 661     return m_libCec->GetMinLibVersion();
 662   }
 663
 664   int GetLibVersionMajor(void)
 665   {
 666     return m_libCec->GetLibVersionMajor();
 667   }
 668
 669   int GetLibVersionMinor(void)
 670   {
 671     return m_libCec->GetLibVersionMinor();
 672   }
 673
 674   CecLogMessage ^ GetNextLogMessage(void)
 675   {
 676     cec_log_message msg;
 677     if (m_libCec->GetNextLogMessage(&msg))
 678     {
 679       return gcnew CecLogMessage(gcnew String(msg.message), (CecLogLevel)msg.level, msg.time);
 680     }
 681
 682     return gcnew CecLogMessage();
 683   }
 684
 685   CecKeypress ^ GetNextKeypress(void)
 686   {
 687     cec_keypress key;
 688     if (m_libCec->GetNextKeypress(&key))
 689     {
 690       return gcnew CecKeypress(key.keycode, key.duration);
 691     }
 692
 693     return gcnew CecKeypress();
 694   }
 695
 696   CecCommand ^ GetNextCommand(void)
 697   {
 698     cec_command command;
 699     if (m_libCec->GetNextCommand(&command))
 700     {
 701       CecCommand ^ retVal = gcnew CecCommand((CecLogicalAddress)command.initiator, (CecLogicalAddress)command.destination, command.ack == 1 ? true : false, command.eom == 1 ? true : false, (CecOpcode)command.opcode, command.transmit_timeout);
 702       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 703         retVal->Parameters->PushBack(command.parameters[iPtr]);
 704       return retVal;
 705     }
 706
 707     return gcnew CecCommand();
 708   }
 709
 710   bool Transmit(CecCommand ^ command)
 711   {
 712     cec_command ccommand;
 713     cec_command::Format(ccommand, (cec_logical_address)command->Initiator, (cec_logical_address)command->Destination, (cec_opcode)command->Opcode);
 714     ccommand.transmit_timeout = command->TransmitTimeout;
 715     ccommand.eom              = command->Eom;
 716     ccommand.ack              = command->Ack;
 717     for (unsigned int iPtr = 0; iPtr < command->Parameters->Size; iPtr++)
 718       ccommand.parameters.PushBack(command->Parameters->Data[iPtr]);
 719
 720     return m_libCec->Transmit(ccommand);
 721   }
 722
 723   bool SetLogicalAddress(CecLogicalAddress logicalAddress)
 724   {
 725     return m_libCec->SetLogicalAddress((cec_logical_address) logicalAddress);
 726   }
 727
 728   bool SetPhysicalAddress(int16_t physicalAddress)
 729   {
 730     return m_libCec->SetPhysicalAddress(physicalAddress);
 731   }
 732
 733   bool PowerOnDevices(CecLogicalAddress logicalAddress)
 734   {
 735     return m_libCec->PowerOnDevices((cec_logical_address) logicalAddress);
 736   }
 737
 738   bool StandbyDevices(CecLogicalAddress logicalAddress)
 739   {
 740     return m_libCec->StandbyDevices((cec_logical_address) logicalAddress);
 741   }
 742
 743   bool PollDevice(CecLogicalAddress logicalAddress)
 744   {
 745     return m_libCec->PollDevice((cec_logical_address) logicalAddress);
 746   }
 747
 748   bool SetActiveSource(CecDeviceType type)
 749   {
 750     return m_libCec->SetActiveSource((cec_device_type) type);
 751   }
 752
 753   bool SetDeckControlMode(CecDeckControlMode mode, bool sendUpdate)
 754   {
 755     return m_libCec->SetDeckControlMode((cec_deck_control_mode) mode, sendUpdate);
 756   }
 757
 758   bool SetDeckInfo(CecDeckInfo info, bool sendUpdate)
 759   {
 760     return m_libCec->SetDeckInfo((cec_deck_info) info, sendUpdate);
 761   }
 762
 763   bool SetInactiveView(void)
 764   {
 765     return m_libCec->SetInactiveView();
 766   }
 767
 768   bool SetMenuState(CecMenuState state, bool sendUpdate)
 769   {
 770     return m_libCec->SetMenuState((cec_menu_state) state, sendUpdate);
 771   }
 772
 773   bool SetOSDString(CecLogicalAddress logicalAddress, CecDisplayControl duration, String ^ message)
 774   {
 775     marshal_context ^ context = gcnew marshal_context();
 776     const char* strMessageC = context->marshal_as<const char*>(message);
 777
 778     bool bReturn = m_libCec->SetOSDString((cec_logical_address) logicalAddress, (cec_display_control) duration, strMessageC);
 779
 780     delete context;
 781     return bReturn;
 782   }
 783
 784   bool SwitchMonitoring(bool enable)
 785   {
 786     return m_libCec->SwitchMonitoring(enable);
 787   }
 788
 789   CecVersion GetDeviceCecVersion(CecLogicalAddress logicalAddress)
 790   {
 791     return (CecVersion) m_libCec->GetDeviceCecVersion((cec_logical_address) logicalAddress);
 792   }
 793
 794   String ^ GetDeviceMenuLanguage(CecLogicalAddress logicalAddress)
 795   {
 796     cec_menu_language lang;
 797     if (m_libCec->GetDeviceMenuLanguage((cec_logical_address) logicalAddress, &lang))
 798     {
 799       return gcnew String(lang.language);
 800     }
 801
 802     return gcnew String("");
 803   }
 804
 805   CecVendorId GetDeviceVendorId(CecLogicalAddress logicalAddress)
 806   {
 807     return (CecVendorId)m_libCec->GetDeviceVendorId((cec_logical_address) logicalAddress);
 808   }
 809
 810   CecPowerStatus GetDevicePowerStatus(CecLogicalAddress logicalAddress)
 811   {
 812     return (CecPowerStatus) m_libCec->GetDevicePowerStatus((cec_logical_address) logicalAddress);
 813   }
 814
 815   CecLogicalAddresses ^ GetActiveDevices(void)
 816   {
 817     CecLogicalAddresses ^ retVal = gcnew CecLogicalAddresses();
 818     unsigned int iDevices = 0;
 819
 820     cec_logical_addresses activeDevices = m_libCec->GetActiveDevices();
 821
 822     for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
 823       if (activeDevices[iPtr])
 824         retVal->Addresses[iDevices++] = (CecLogicalAddress)iPtr;
 825
 826     return retVal;
 827   }
 828
 829   bool IsActiveDevice(CecLogicalAddress logicalAddress)
 830   {
 831     return m_libCec->IsActiveDevice((cec_logical_address)logicalAddress);
 832   }
 833
 834   bool IsActiveDeviceType(CecDeviceType type)
 835   {
 836     return m_libCec->IsActiveDeviceType((cec_device_type)type);
 837   }
 838
 839   bool SetHDMIPort(CecLogicalAddress address, uint8_t port)
 840   {
 841     return m_libCec->SetHDMIPort((cec_logical_address)address, port);
 842   }
 843
 844   uint8_t VolumeUp(bool wait)
 845   {
 846     return m_libCec->VolumeUp(wait);
 847   }
 848
 849   uint8_t VolumeDown(bool wait)
 850   {
 851     return m_libCec->VolumeDown(wait);
 852   }
 853
 854   uint8_t MuteAudio(bool wait)
 855   {
 856     return m_libCec->MuteAudio(wait);
 857   }
 858
 859   bool SendKeypress(CecLogicalAddress destination, CecUserControlCode key, bool wait)
 860   {
 861     return m_libCec->SendKeypress((cec_logical_address)destination, (cec_user_control_code)key, wait);
 862   }
 863
 864   bool SendKeyRelease(CecLogicalAddress destination, bool wait)
 865   {
 866     return m_libCec->SendKeyRelease((cec_logical_address)destination, wait);
 867   }
 868
 869   String ^ GetDeviceOSDName(CecLogicalAddress logicalAddress)
 870   {
 871     cec_osd_name osd = m_libCec->GetDeviceOSDName((cec_logical_address) logicalAddress);
 872     return gcnew String(osd.name);
 873   }
 874
 875   CecLogicalAddress GetActiveSource()
 876   {
 877     return (CecLogicalAddress)m_libCec->GetActiveSource();
 878   }
 879
 880   bool IsActiveSource(CecLogicalAddress logicalAddress)
 881   {
 882     return m_libCec->IsActiveSource((cec_logical_address)logicalAddress);
 883   }
 884
 885   uint16_t GetDevicePhysicalAddress(CecLogicalAddress iAddress)
 886   {
 887     return m_libCec->GetDevicePhysicalAddress((cec_logical_address)iAddress);
 888   }
 889
 890   String ^ ToString(CecLogicalAddress iAddress)
 891   {
 892     const char *retVal = m_libCec->ToString((cec_logical_address)iAddress);
 893     return gcnew String(retVal);
 894   }
 895
 896   String ^ ToString(CecVendorId iVendorId)
 897   {
 898     const char *retVal = m_libCec->ToString((cec_vendor_id)iVendorId);
 899     return gcnew String(retVal);
 900   }
 901
 902   String ^ ToString(CecVersion iVersion)
 903   {
 904     const char *retVal = m_libCec->ToString((cec_version)iVersion);
 905     return gcnew String(retVal);
 906   }
 907
 908   String ^ ToString(CecPowerStatus iState)
 909   {
 910     const char *retVal = m_libCec->ToString((cec_power_status)iState);
 911     return gcnew String(retVal);
 912   }
 913
 914   String ^ ToString(CecMenuState iState)
 915   {
 916     const char *retVal = m_libCec->ToString((cec_menu_state)iState);
 917     return gcnew String(retVal);
 918   }
 919
 920   String ^ ToString(CecDeckControlMode iMode)
 921   {
 922     const char *retVal = m_libCec->ToString((cec_deck_control_mode)iMode);
 923     return gcnew String(retVal);
 924   }
 925
 926   String ^ ToString(CecDeckInfo status)
 927   {
 928     const char *retVal = m_libCec->ToString((cec_deck_info)status);
 929     return gcnew String(retVal);
 930   }
 931
 932   String ^ ToString(CecOpcode opcode)
 933   {
 934     const char *retVal = m_libCec->ToString((cec_opcode)opcode);
 935     return gcnew String(retVal);
 936   }
 937
 938   String ^ ToString(CecSystemAudioStatus mode)
 939   {
 940     const char *retVal = m_libCec->ToString((cec_system_audio_status)mode);
 941     return gcnew String(retVal);
 942   }
 943
 944   String ^ ToString(CecAudioStatus status)
 945   {
 946     const char *retVal = m_libCec->ToString((cec_audio_status)status);
 947     return gcnew String(retVal);
 948   }
 949
 950 private:
 951   void DestroyDelegates()
 952   {
 953     m_logMessageGCHandle.Free();
 954     m_keypressGCHandle.Free();
 955     m_commandGCHandle.Free();
 956   }
 957
 958   // managed callback methods
 959   int CecLogMessageManaged(const cec_log_message &message)
 960   {
 961     int iReturn(0);
 962     if (m_bHasCallbacks)
 963       iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew String(message.message), (CecLogLevel)message.level, message.time));
 964     return iReturn;
 965   }
 966
 967   int CecKeyPressManaged(const cec_keypress &key)
 968   {
 969     int iReturn(0);
 970     if (m_bHasCallbacks)
 971       iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
 972     return iReturn;
 973   }
 974
 975   int CecCommandManaged(const cec_command &command)
 976   {
 977     int iReturn(0);
 978     if (m_bHasCallbacks)
 979     {
 980       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);
 981       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 982         newCommand->Parameters->PushBack(command.parameters[iPtr]);
 983       iReturn = m_callbacks->ReceiveCommand(newCommand);
 984     }
 985     return iReturn;
 986   }
 987
 988   ICECAdapter *        m_libCec;
 989   CecCallbackMethods ^ m_callbacks;
 990   bool                 m_bHasCallbacks;
 991
 992   CecLogMessageManagedDelegate ^ m_logMessageDelegate;
 993   static GCHandle                m_logMessageGCHandle;
 994   LOGCB                          m_logMessageCallback;
 995
 996   CecKeyPressManagedDelegate ^   m_keypressDelegate;
 997   static GCHandle                m_keypressGCHandle;
 998   KEYCB                          m_keypressCallback;
 999
1000   CecCommandManagedDelegate ^    m_commandDelegate;
1001   static GCHandle                m_commandGCHandle;
1002   COMMANDCB                      m_commandCallback;
1003 };