repositories / deb_libcec.git / blame
| 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, | |
| 32403cc3 | 328 | Version1_5_0 = 0x1500 |
| 4ef3b314 LOK |
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); | |
| b7907707 LOK |
363 | Clear(); |
| 364 | } | |
| 365 | ||
| 366 | void Clear(void) | |
| 367 | { | |
| 4ef3b314 LOK |
368 | for (unsigned int iPtr = 0; iPtr < 16; iPtr++) |
| 369 | Addresses[iPtr] = CecLogicalAddress::Unregistered; | |
| 370 | } | |
| 371 | ||
| 372 | bool IsSet(CecLogicalAddress iAddress) | |
| 373 | { | |
| 374 | return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unregistered; | |
| 375 | } | |
| 376 | ||
| b7907707 LOK |
377 | void Set(CecLogicalAddress iAddress) |
| 378 | { | |
| 379 | Addresses[(unsigned int)iAddress] = iAddress; | |
| 380 | } | |
| 381 | ||
| a9fb46b4 | 382 | property CecLogicalAddress Primary; |
| 4ef3b314 LOK |
383 | property array<CecLogicalAddress> ^ Addresses; |
| 384 | }; | |
| 385 | ||
| 386 | public ref class CecDatapacket | |
| 387 | { | |
| 388 | public: | |
| 389 | CecDatapacket(void) | |
| 390 | { | |
| 391 | Data = gcnew array<uint8_t>(100); | |
| 392 | Size = 0; | |
| 393 | } | |
| 394 | ||
| 395 | void PushBack(uint8_t data) | |
| 396 | { | |
| 397 | if (Size < 100) | |
| 398 | { | |
| 399 | Data[Size] = data; | |
| 400 | Size++; | |
| 401 | } | |
| 402 | } | |
| 403 | ||
| 404 | property array<uint8_t> ^ Data; | |
| 405 | property uint8_t Size; | |
| 406 | }; | |
| 407 | ||
| 408 | public ref class CecCommand | |
| 409 | { | |
| 410 | public: | |
| 411 | CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout) | |
| 412 | { | |
| 413 | Initiator = iInitiator; | |
| 414 | Destination = iDestination; | |
| 415 | Ack = bAck; | |
| 416 | Eom = bEom; | |
| 417 | Opcode = iOpcode; | |
| 418 | OpcodeSet = true; | |
| 419 | TransmitTimeout = iTransmitTimeout; | |
| 420 | Parameters = gcnew CecDatapacket; | |
| 421 | Empty = false; | |
| 422 | } | |
| 423 | ||
| 424 | CecCommand(void) | |
| 425 | { | |
| 426 | Initiator = CecLogicalAddress::Unknown; | |
| 427 | Destination = CecLogicalAddress::Unknown; | |
| 428 | Ack = false; | |
| 429 | Eom = false; | |
| 430 | Opcode = CecOpcode::None; | |
| 431 | OpcodeSet = false; | |
| 432 | TransmitTimeout = 0; | |
| 433 | Parameters = gcnew CecDatapacket; | |
| 434 | Empty = true; | |
| 435 | } | |
| 436 | ||
| 437 | void PushBack(uint8_t data) | |
| 438 | { | |
| 439 | if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown) | |
| 440 | { | |
| 441 | Initiator = (CecLogicalAddress) (data >> 4); | |
| 442 | Destination = (CecLogicalAddress) (data & 0xF); | |
| 443 | } | |
| 444 | else if (!OpcodeSet) | |
| 445 | { | |
| 446 | OpcodeSet = true; | |
| 447 | Opcode = (CecOpcode)data; | |
| 448 | } | |
| 449 | else | |
| 450 | { | |
| 451 | Parameters->PushBack(data); | |
| 452 | } | |
| 453 | } | |
| 454 | ||
| 455 | property bool Empty; | |
| 456 | property CecLogicalAddress Initiator; | |
| 457 | property CecLogicalAddress Destination; | |
| 458 | property bool Ack; | |
| 459 | property bool Eom; | |
| 460 | property CecOpcode Opcode; | |
| 461 | property CecDatapacket ^ Parameters; | |
| 462 | property bool OpcodeSet; | |
| 463 | property int32_t TransmitTimeout; | |
| 464 | }; | |
| 465 | ||
| 466 | public ref class CecKeypress | |
| 467 | { | |
| 468 | public: | |
| 469 | CecKeypress(int iKeycode, unsigned int iDuration) | |
| 470 | { | |
| 471 | Keycode = iKeycode; | |
| 472 | Duration = iDuration; | |
| 473 | Empty = false; | |
| 474 | } | |
| 475 | ||
| 476 | CecKeypress(void) | |
| 477 | { | |
| 478 | Keycode = 0; | |
| 479 | Duration = 0; | |
| 480 | Empty = true; | |
| 481 | } | |
| 482 | ||
| 483 | property bool Empty; | |
| 484 | property int Keycode; | |
| 485 | property unsigned int Duration; | |
| 486 | }; | |
| 487 | ||
| 488 | public ref class CecLogMessage | |
| 489 | { | |
| 490 | public: | |
| 491 | CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime) | |
| 492 | { | |
| 493 | Message = strMessage; | |
| 494 | Level = iLevel; | |
| 495 | Time = iTime; | |
| 496 | Empty = false; | |
| 497 | } | |
| 498 | ||
| 499 | CecLogMessage(void) | |
| 500 | { | |
| 501 | Message = ""; | |
| 502 | Level = CecLogLevel::None; | |
| 503 | Time = 0; | |
| 504 | Empty = true; | |
| 505 | } | |
| 506 | ||
| 507 | property bool Empty; | |
| 508 | property System::String ^Message; | |
| 509 | property CecLogLevel Level; | |
| 510 | property int64_t Time; | |
| 511 | }; | |
| 512 | ||
| 32403cc3 LOK |
513 | ref class CecCallbackMethods; //forward |
| 514 | public ref class LibCECConfiguration | |
| 515 | { | |
| 516 | public: | |
| 517 | LibCECConfiguration(void) | |
| 518 | { | |
| 519 | DeviceName = ""; | |
| 520 | DeviceTypes = gcnew CecDeviceTypeList(); | |
| 521 | PhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS; | |
| 522 | BaseDevice = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE; | |
| 523 | HDMIPort = CEC_DEFAULT_HDMI_PORT; | |
| 524 | ClientVersion = CecClientVersion::VersionPre1_5; | |
| b7907707 | 525 | TvVendor = CecVendorId::Unknown; |
| 32403cc3 LOK |
526 | |
| 527 | GetSettingsFromROM = false; | |
| 528 | UseTVMenuLanguage = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE == 1; | |
| b7907707 LOK |
529 | ActivateSource = CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1; |
| 530 | ||
| 531 | WakeDevices = gcnew CecLogicalAddresses(); | |
| 532 | if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1) | |
| 533 | WakeDevices->Set(CecLogicalAddress::Tv); | |
| 534 | ||
| 535 | PowerOffDevices = gcnew CecLogicalAddresses(); | |
| 536 | if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1) | |
| 537 | PowerOffDevices->Set(CecLogicalAddress::Broadcast); | |
| 538 | ||
| 32403cc3 LOK |
539 | PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1; |
| 540 | PowerOffOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1; | |
| 541 | } | |
| 542 | ||
| 543 | void SetCallbacks(CecCallbackMethods ^callbacks) | |
| 544 | { | |
| 545 | Callbacks = callbacks; | |
| 546 | } | |
| 547 | ||
| b7907707 LOK |
548 | property System::String ^ DeviceName; |
| 549 | property CecDeviceTypeList ^ DeviceTypes; | |
| 550 | property uint16_t PhysicalAddress; | |
| 551 | property CecLogicalAddress BaseDevice; | |
| 552 | property uint8_t HDMIPort; | |
| 553 | property CecClientVersion ClientVersion; | |
| 554 | property CecVendorId TvVendor; | |
| 32403cc3 LOK |
555 | |
| 556 | // player specific settings | |
| b7907707 LOK |
557 | property bool GetSettingsFromROM; |
| 558 | property bool UseTVMenuLanguage; | |
| 559 | property bool ActivateSource; | |
| 560 | property CecLogicalAddresses ^WakeDevices; | |
| 561 | property CecLogicalAddresses ^PowerOffDevices; | |
| 562 | property bool PowerOffScreensaver; | |
| 563 | property bool PowerOffOnStandby; | |
| 564 | ||
| 565 | property CecCallbackMethods ^ Callbacks; | |
| 32403cc3 LOK |
566 | }; |
| 567 | ||
| 4ef3b314 LOK |
568 | // the callback methods are called by unmanaged code, so we need some delegates for this |
| 569 | #pragma unmanaged | |
| 570 | // unmanaged callback methods | |
| 571 | typedef int (__stdcall *LOGCB) (const CEC::cec_log_message &message); | |
| 572 | typedef int (__stdcall *KEYCB) (const CEC::cec_keypress &key); | |
| 573 | typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command); | |
| 32403cc3 | 574 | typedef int (__stdcall *CONFIGCB) (const CEC::libcec_configuration &config); |
| 4ef3b314 LOK |
575 | |
| 576 | static LOGCB g_logCB; | |
| 577 | static KEYCB g_keyCB; | |
| 578 | static COMMANDCB g_commandCB; | |
| 32403cc3 | 579 | static CONFIGCB g_configCB; |
| 4ef3b314 LOK |
580 | static CEC::ICECCallbacks g_cecCallbacks; |
| 581 | ||
| 582 | int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message) | |
| 583 | { | |
| 584 | if (g_logCB) | |
| 585 | return g_logCB(message); | |
| 586 | return 0; | |
| 587 | } | |
| 588 | ||
| 589 | int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key) | |
| 590 | { | |
| 591 | if (g_keyCB) | |
| 592 | return g_keyCB(key); | |
| 593 | return 0; | |
| 594 | } | |
| 595 | ||
| 596 | int CecCommandCB(void *cbParam, const CEC::cec_command &command) | |
| 597 | { | |
| 598 | if (g_commandCB) | |
| 599 | return g_commandCB(command); | |
| 600 | return 0; | |
| 601 | } | |
| 602 | ||
| 32403cc3 LOK |
603 | int CecConfigCB(void *cbParam, const CEC::libcec_configuration &config) |
| 604 | { | |
| 605 | if (g_configCB) | |
| 606 | return g_configCB(config); | |
| 607 | return 0; | |
| 608 | } | |
| 609 | ||
| 4ef3b314 LOK |
610 | #pragma managed |
| 611 | // delegates for the unmanaged callback methods | |
| 612 | public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &); | |
| 613 | public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &); | |
| 614 | public delegate int CecCommandManagedDelegate(const CEC::cec_command &); | |
| 32403cc3 | 615 | public delegate int CecConfigManagedDelegate(const CEC::libcec_configuration &); |
| 4ef3b314 LOK |
616 | |
| 617 | // callback method interface | |
| 618 | public ref class CecCallbackMethods | |
| 619 | { | |
| 620 | public: | |
| 621 | CecCallbackMethods(void) | |
| 622 | { | |
| 623 | m_bHasCallbacks = false; | |
| 624 | msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context(); | |
| 625 | ||
| 626 | // create the delegate method for the log message callback | |
| 627 | m_logMessageDelegate = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged); | |
| 628 | m_logMessageGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate); | |
| 629 | g_logCB = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer()); | |
| 630 | g_cecCallbacks.CBCecLogMessage = CecLogMessageCB; | |
| 631 | ||
| 632 | // create the delegate method for the keypress callback | |
| 633 | m_keypressDelegate = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged); | |
| 634 | m_keypressGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate); | |
| 635 | g_keyCB = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer()); | |
| 636 | g_cecCallbacks.CBCecKeyPress = CecKeyPressCB; | |
| 637 | ||
| 638 | // create the delegate method for the command callback | |
| 639 | m_commandDelegate = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged); | |
| 640 | m_commandGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate); | |
| 641 | g_commandCB = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer()); | |
| 642 | g_cecCallbacks.CBCecCommand = CecCommandCB; | |
| 643 | ||
| 32403cc3 LOK |
644 | // create the delegate method for the configuration change callback |
| 645 | m_configDelegate = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged); | |
| 646 | m_configGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate); | |
| 647 | g_configCB = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer()); | |
| 648 | g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB; | |
| 649 | ||
| 4ef3b314 LOK |
650 | delete context; |
| 651 | } | |
| 652 | ||
| 653 | ~CecCallbackMethods(void) | |
| 654 | { | |
| 655 | DestroyDelegates(); | |
| 656 | } | |
| 657 | ||
| 658 | protected: | |
| 659 | !CecCallbackMethods(void) | |
| 660 | { | |
| 661 | DestroyDelegates(); | |
| 662 | } | |
| 663 | ||
| 664 | public: | |
| 665 | virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks) | |
| 666 | { | |
| 667 | if (!m_bHasCallbacks) | |
| 668 | { | |
| 669 | m_bHasCallbacks = true; | |
| 670 | m_callbacks = callbacks; | |
| 671 | return true; | |
| 672 | } | |
| 673 | ||
| 674 | return false; | |
| 675 | } | |
| 676 | ||
| 677 | virtual int ReceiveLogMessage(CecLogMessage ^ message) | |
| 678 | { | |
| 679 | return 0; | |
| 680 | } | |
| 681 | ||
| 682 | virtual int ReceiveKeypress(CecKeypress ^ key) | |
| 683 | { | |
| 684 | return 0; | |
| 685 | } | |
| 686 | ||
| 687 | virtual int ReceiveCommand(CecCommand ^ command) | |
| 688 | { | |
| 689 | return 0; | |
| 690 | } | |
| 691 | ||
| 32403cc3 LOK |
692 | virtual int ConfigurationChanged(LibCECConfiguration ^ config) |
| 693 | { | |
| 694 | return 0; | |
| 695 | } | |
| 4ef3b314 LOK |
696 | protected: |
| 697 | // managed callback methods | |
| 698 | int CecLogMessageManaged(const CEC::cec_log_message &message) | |
| 699 | { | |
| 700 | int iReturn(0); | |
| 701 | if (m_bHasCallbacks) | |
| 702 | iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time)); | |
| 703 | return iReturn; | |
| 704 | } | |
| 705 | ||
| 706 | int CecKeyPressManaged(const CEC::cec_keypress &key) | |
| 707 | { | |
| 708 | int iReturn(0); | |
| 709 | if (m_bHasCallbacks) | |
| 710 | iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration)); | |
| 711 | return iReturn; | |
| 712 | } | |
| 713 | ||
| 714 | int CecCommandManaged(const CEC::cec_command &command) | |
| 715 | { | |
| 716 | int iReturn(0); | |
| 717 | if (m_bHasCallbacks) | |
| 718 | { | |
| 719 | 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); | |
| 720 | for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++) | |
| 721 | newCommand->Parameters->PushBack(command.parameters[iPtr]); | |
| 722 | iReturn = m_callbacks->ReceiveCommand(newCommand); | |
| 723 | } | |
| 724 | return iReturn; | |
| 725 | } | |
| 726 | ||
| 32403cc3 LOK |
727 | int CecConfigManaged(const CEC::libcec_configuration &config) |
| 728 | { | |
| 729 | int iReturn(0); | |
| 730 | if (m_bHasCallbacks) | |
| 731 | { | |
| 732 | LibCECConfiguration ^netConfig = gcnew LibCECConfiguration(); | |
| 733 | netConfig->DeviceName = gcnew System::String(config.strDeviceName); | |
| 734 | for (unsigned int iPtr = 0; iPtr < 5; iPtr++) | |
| 735 | netConfig->DeviceTypes->Types[iPtr] = (CecDeviceType)config.deviceTypes.types[iPtr]; | |
| 736 | ||
| 737 | netConfig->PhysicalAddress = config.iPhysicalAddress; | |
| 738 | netConfig->BaseDevice = (CecLogicalAddress)config.baseDevice; | |
| 739 | netConfig->HDMIPort = config.iHDMIPort; | |
| 740 | netConfig->ClientVersion = (CecClientVersion)config.clientVersion; | |
| 741 | netConfig->GetSettingsFromROM = config.bGetSettingsFromROM == 1; | |
| b7907707 LOK |
742 | netConfig->ActivateSource = config.bActivateSource == 1; |
| 743 | ||
| 744 | netConfig->WakeDevices->Clear(); | |
| 745 | int iDevices(0); | |
| 746 | for (uint8_t iPtr = 0; iPtr <= 16; iPtr++) | |
| 747 | if (config.wakeDevices[iPtr]) | |
| 748 | netConfig->WakeDevices->Addresses[iDevices++] = (CecLogicalAddress)iPtr; | |
| 749 | ||
| 750 | netConfig->PowerOffDevices->Clear(); | |
| 751 | iDevices = 0; | |
| 752 | for (uint8_t iPtr = 0; iPtr <= 16; iPtr++) | |
| 753 | if (config.powerOffDevices[iPtr]) | |
| 754 | netConfig->PowerOffDevices->Addresses[iDevices++] = (CecLogicalAddress)iPtr; | |
| 755 | ||
| 32403cc3 LOK |
756 | netConfig->PowerOffScreensaver = config.bPowerOffScreensaver == 1; |
| 757 | netConfig->PowerOffOnStandby = config.bPowerOffOnStandby == 1; | |
| 758 | ||
| 759 | iReturn = m_callbacks->ConfigurationChanged(netConfig); | |
| 760 | } | |
| 761 | return iReturn; | |
| 762 | } | |
| 763 | ||
| 4ef3b314 LOK |
764 | void DestroyDelegates() |
| 765 | { | |
| 006b76b9 LOK |
766 | if (m_bHasCallbacks) |
| 767 | { | |
| 768 | m_bHasCallbacks = false; | |
| 769 | delete m_callbacks; | |
| 770 | m_logMessageGCHandle.Free(); | |
| 771 | m_keypressGCHandle.Free(); | |
| 772 | m_commandGCHandle.Free(); | |
| 773 | } | |
| 4ef3b314 LOK |
774 | } |
| 775 | ||
| 776 | CecLogMessageManagedDelegate ^ m_logMessageDelegate; | |
| 777 | static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle; | |
| 778 | LOGCB m_logMessageCallback; | |
| 779 | ||
| 780 | CecKeyPressManagedDelegate ^ m_keypressDelegate; | |
| 781 | static System::Runtime::InteropServices::GCHandle m_keypressGCHandle; | |
| 782 | KEYCB m_keypressCallback; | |
| 783 | ||
| 784 | CecCommandManagedDelegate ^ m_commandDelegate; | |
| 785 | static System::Runtime::InteropServices::GCHandle m_commandGCHandle; | |
| 786 | COMMANDCB m_commandCallback; | |
| 787 | ||
| 32403cc3 LOK |
788 | CecConfigManagedDelegate ^ m_configDelegate; |
| 789 | static System::Runtime::InteropServices::GCHandle m_configGCHandle; | |
| 790 | CONFIGCB m_configCallback; | |
| 791 | ||
| 4ef3b314 LOK |
792 | CecCallbackMethods ^ m_callbacks; |
| 793 | bool m_bHasCallbacks; | |
| 794 | }; | |
| 4ef3b314 | 795 | } |