1 #pragma once 2 /* 3 * This file is part of the libCEC(R) library. 4 * 5 * libCEC(R) is Copyright (C) 2011-2015 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 #ifndef CECTYPES_H_ 35 #define CECTYPES_H_ 36 37 #include "version.h" 38 #include <stdint.h> 39 #include <string.h> 40 41 #if defined(_WIN32) || defined(_WIN64) 42 #define CEC_CDECL __cdecl 43 #else 44 #define CEC_CDECL 45 #endif 46 47 #if !defined(DECLSPEC) 48 #if defined(_WIN32) || defined(_WIN64) 49 #include <windows.h> 50 #if defined DLL_EXPORT 51 #define DECLSPEC __declspec(dllexport) 52 #else 53 #define DECLSPEC __declspec(dllimport) 54 #endif 55 #else 56 #define DECLSPEC 57 #endif 58 #endif 59 60 #ifdef __cplusplus 61 #include <string> 62 extern "C" { 63 namespace CEC { 64 #endif 65 66 /*! 67 * default physical address 1.0.0.0, HDMI port 1 68 */ 69 #define CEC_DEFAULT_PHYSICAL_ADDRESS 0x1000 70 /*! 71 * default HDMI port to which the adapter is connected, port 1 72 */ 73 #define CEC_DEFAULT_HDMI_PORT 1 74 /*! 75 * default logical address of the device to which the adapter is connected, TV 76 */ 77 #define CEC_DEFAULT_BASE_DEVICE 0 78 79 /*! 80 * timeout in milliseconds to send a key release event after receiving a key press 81 */ 82 #define CEC_BUTTON_TIMEOUT 500 83 84 /*! 85 * don't send the same key twice within this timeout in milliseconds 86 */ 87 #define CEC_DOUBLE_TAP_TIMEOUT_MS 200 88 89 /*! 90 * don't query the power state for the same device within this timeout in milliseconds 91 */ 92 #define CEC_POWER_STATE_REFRESH_TIME 30000 93 94 /*! 95 * unknown firmware version value 96 */ 97 #define CEC_FW_VERSION_UNKNOWN 0xFFFF 98 99 /*! 100 * unknown build date value 101 */ 102 #define CEC_FW_BUILD_UNKNOWN 0 103 104 /*! 105 * maximum number of retries when opening a connection 106 */ 107 #define CEC_CONNECT_TRIES 3 108 109 /*! 110 * physical address of the TV 111 */ 112 #define CEC_PHYSICAL_ADDRESS_TV 0 113 114 /*! 115 * minimum physical address for the adapter 116 */ 117 #define CEC_MIN_PHYSICAL_ADDRESS 0x1000 118 119 /*! 120 * maximum physical address for the adapter 121 */ 122 #define CEC_MAX_PHYSICAL_ADDRESS 0xFFFE 123 124 /*! 125 * invalid physical address value 126 */ 127 #define CEC_INVALID_PHYSICAL_ADDRESS 0xFFFF 128 129 /*! 130 * minimum vendor ID value 131 */ 132 #define CEC_MIN_VENDORID 1 133 134 /*! 135 * maximum vendor ID value 136 */ 137 #define CEC_MAX_VENDORID 0xFFFFFE 138 139 /*! 140 * invalid vendor ID value 141 */ 142 #define CEC_INVALID_VENDORID 0xFFFFFF 143 144 /*! 145 * minimum HDMI port number value 146 */ 147 #define CEC_MIN_HDMI_PORTNUMBER 1 148 149 /*! 150 * maximum HDMI port number value 151 */ 152 #define CEC_MAX_HDMI_PORTNUMBER 15 153 154 /*! 155 * invalid HDMI port number value 156 */ 157 #define CEC_HDMI_PORTNUMBER_NONE 0 158 159 /*! 160 * default value for settings "activate source" 161 */ 162 #define CEC_DEFAULT_SETTING_ACTIVATE_SOURCE 1 163 164 /*! 165 * default value for settings "power off on shutdown" 166 */ 167 #define CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN 1 168 169 /*! 170 * default value for settings "power off on standby" 171 */ 172 #define CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY 1 173 174 /*! 175 * default value for settings "device menu language" 176 */ 177 #define CEC_DEFAULT_DEVICE_LANGUAGE "eng" 178 179 /*! 180 * default value for settings "autodetect physical address" 181 */ 182 #define CEC_DEFAULT_SETTING_AUTODETECT_ADDRESS 0 183 184 /*! 185 * default value for settings "get settings from ROM" 186 */ 187 #define CEC_DEFAULT_SETTING_GET_SETTINGS_FROM_ROM 0 188 189 /*! 190 * default value for settings "libCEC CEC version" 191 */ 192 #define CEC_DEFAULT_SETTING_CEC_VERSION 0x05 193 194 /*! 195 * wait this amount of milliseconds before retrying to send a failed message 196 */ 197 #define CEC_DEFAULT_TRANSMIT_RETRY_WAIT 500 198 199 /*! 200 * transmission fails when not acked within this amount of milliseconds after sending the initial packet 201 */ 202 #define CEC_DEFAULT_TRANSMIT_TIMEOUT 1000 203 204 /*! 205 * wait this amount of milliseconds for an ack 206 */ 207 #define CEC_DEFAULT_TRANSMIT_WAIT 1000 208 209 /*! 210 * default number of retries 211 */ 212 #define CEC_DEFAULT_TRANSMIT_RETRIES 1 213 214 /*! 215 * default connection timeout in milliseconds 216 */ 217 #define CEC_DEFAULT_CONNECT_TIMEOUT 10000 218 219 /*! 220 * wait this amount of milliseconds before retrying when failing to connect 221 */ 222 #define CEC_DEFAULT_CONNECT_RETRY_WAIT 1000 223 224 /*! 225 * default serial baudrate 226 */ 227 #define CEC_SERIAL_DEFAULT_BAUDRATE 38400 228 229 /*! 230 * maximum time to wait when clearing input 231 */ 232 #define CEC_CLEAR_INPUT_DEFAULT_WAIT 1000 233 234 /*! 235 * wait this amount of milliseconds before retrying when libCEC failed to make itself the active source 236 */ 237 #define CEC_ACTIVE_SOURCE_SWITCH_RETRY_TIME_MS 1000 238 239 /*! 240 * don't forward any power off command to the client application for this amount of milliseconds after sending a power off command 241 */ 242 #define CEC_FORWARD_STANDBY_MIN_INTERVAL 10000 243 244 /*! 245 * default timeout in milliseconds for combo keys 246 */ 247 #define CEC_DEFAULT_COMBO_TIMEOUT_MS 1000 248 249 /*! 250 * the virtual device path to use for the Raspberry Pi's CEC wire 251 */ 252 #define CEC_RPI_VIRTUAL_PATH "Raspberry Pi" 253 254 /*! 255 * the name of the virtual COM port to use for the Raspberry Pi's CEC wire 256 */ 257 #define CEC_RPI_VIRTUAL_COM "RPI" 258 259 /*! 260 * the path to use for the TDA995x's CEC wire 261 */ 262 #define CEC_TDA995x_PATH "/dev/hdmicec" 263 264 /*! 265 * the name of the virtual COM port to use for the TDA995x's CEC wire 266 */ 267 #define CEC_TDA995x_VIRTUAL_COM "CuBox" 268 269 /*! 270 * the path to use for the Exynos HDMI CEC device 271 */ 272 #define CEC_EXYNOS_PATH "/dev/CEC" 273 274 /*! 275 * the name of the virtual COM port to use for the EXYNOS' CEC wire 276 */ 277 #define CEC_EXYNOS_VIRTUAL_COM "Exynos" 278 279 /** 280 * Maximum size of a data packet 281 */ 282 #define CEC_MAX_DATA_PACKET_SIZE (16 * 4) 283 284 /*! 285 * the path to use for the Linux CEC device 286 */ 287 #define CEC_LINUX_PATH "/dev/cec0" 288 289 /*! 290 * the name of the virtual COM port to use for the Linux' CEC wire 291 */ 292 #define CEC_LINUX_VIRTUAL_COM "Linux" 293 294 /*! 295 * the path to use for the AOCEC HDMI CEC device 296 */ 297 #define CEC_AOCEC_PATH "/dev/aocec" 298 299 /*! 300 * the name of the virtual COM port to use for the AOCEC' CEC wire 301 */ 302 #define CEC_AOCEC_VIRTUAL_COM "AOCEC" 303 304 /*! 305 * the path to use for the i.MX CEC wire 306 */ 307 #define CEC_IMX_PATH "/dev/mxc_hdmi_cec" 308 309 /*! 310 * the name of the virtual COM port to use for the i.MX CEC wire 311 */ 312 #define CEC_IMX_VIRTUAL_COM "i.MX" 313 314 /*! 315 * Mimimum client version 316 */ 317 #define CEC_MIN_LIB_VERSION 4 318 319 #define MSGSTART 0xFF 320 #define MSGEND 0xFE 321 #define MSGESC 0xFD 322 #define ESCOFFSET 3 323 324 #define DOUBLE_TAP_TIMEOUT_UNIT_SIZE (50) 325 326 // defines to make compile time checks for certain features easy 327 #define CEC_FEATURE_CONFIGURABLE_COMBO_KEY 1 328 329 typedef enum cec_abort_reason 330 { 331 CEC_ABORT_REASON_UNRECOGNIZED_OPCODE = 0,//!< CEC_ABORT_REASON_UNRECOGNIZED_OPCODE 332 CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND = 1,//!< CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND 333 CEC_ABORT_REASON_CANNOT_PROVIDE_SOURCE = 2,//!< CEC_ABORT_REASON_CANNOT_PROVIDE_SOURCE 334 CEC_ABORT_REASON_INVALID_OPERAND = 3,//!< CEC_ABORT_REASON_INVALID_OPERAND 335 CEC_ABORT_REASON_REFUSED = 4 //!< CEC_ABORT_REASON_REFUSED 336 } cec_abort_reason; 337 338 typedef enum cec_analogue_broadcast_type 339 { 340 CEC_ANALOGUE_BROADCAST_TYPE_CABLE = 0x00, 341 CEC_ANALOGUE_BROADCAST_TYPE_SATELLITE = 0x01, 342 CEC_ANALOGUE_BROADCAST_TYPE_TERRESTIAL = 0x02 343 } cec_analogue_broadcast_type; 344 345 typedef enum cec_audio_rate 346 { 347 CEC_AUDIO_RATE_RATE_CONTROL_OFF = 0, 348 CEC_AUDIO_RATE_STANDARD_RATE_100 = 1, 349 CEC_AUDIO_RATE_FAST_RATE_MAX_101 = 2, 350 CEC_AUDIO_RATE_SLOW_RATE_MIN_99 = 3, 351 CEC_AUDIO_RATE_STANDARD_RATE_100_0 = 4, 352 CEC_AUDIO_RATE_FAST_RATE_MAX_100_1 = 5, 353 CEC_AUDIO_RATE_SLOW_RATE_MIN_99_9 = 6 354 } cec_audio_rate; 355 356 typedef enum cec_audio_status 357 { 358 CEC_AUDIO_MUTE_STATUS_MASK = 0x80, 359 CEC_AUDIO_VOLUME_STATUS_MASK = 0x7F, 360 CEC_AUDIO_VOLUME_MIN = 0x00, 361 CEC_AUDIO_VOLUME_MAX = 0x64, 362 CEC_AUDIO_VOLUME_STATUS_UNKNOWN = 0x7F 363 } cec_audio_status; 364 365 typedef enum cec_boolean 366 { 367 CEC_FALSE = 0, 368 CEC_TRUE = 1 369 } cec_boolean; 370 371 typedef enum cec_version 372 { 373 CEC_VERSION_UNKNOWN = 0x00, 374 CEC_VERSION_1_2 = 0x01, 375 CEC_VERSION_1_2A = 0x02, 376 CEC_VERSION_1_3 = 0x03, 377 CEC_VERSION_1_3A = 0x04, 378 CEC_VERSION_1_4 = 0x05, 379 CEC_VERSION_2_0 = 0x06, 380 } cec_version; 381 382 typedef enum cec_channel_identifier 383 { 384 CEC_CHANNEL_NUMBER_FORMAT_MASK = 0xFC000000, 385 CEC_1_PART_CHANNEL_NUMBER = 0x04000000, 386 CEC_2_PART_CHANNEL_NUMBER = 0x08000000, 387 CEC_MAJOR_CHANNEL_NUMBER_MASK = 0x3FF0000, 388 CEC_MINOR_CHANNEL_NUMBER_MASK = 0xFFFF 389 } cec_channel_identifier; 390 391 typedef enum cec_deck_control_mode 392 { 393 CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND = 1, 394 CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND = 2, 395 CEC_DECK_CONTROL_MODE_STOP = 3, 396 CEC_DECK_CONTROL_MODE_EJECT = 4 397 } cec_deck_control_mode; 398 399 typedef enum cec_deck_info 400 { 401 CEC_DECK_INFO_PLAY = 0x11, 402 CEC_DECK_INFO_RECORD = 0x12, 403 CEC_DECK_INFO_PLAY_REVERSE = 0x13, 404 CEC_DECK_INFO_STILL = 0x14, 405 CEC_DECK_INFO_SLOW = 0x15, 406 CEC_DECK_INFO_SLOW_REVERSE = 0x16, 407 CEC_DECK_INFO_FAST_FORWARD = 0x17, 408 CEC_DECK_INFO_FAST_REVERSE = 0x18, 409 CEC_DECK_INFO_NO_MEDIA = 0x19, 410 CEC_DECK_INFO_STOP = 0x1A, 411 CEC_DECK_INFO_SKIP_FORWARD_WIND = 0x1B, 412 CEC_DECK_INFO_SKIP_REVERSE_REWIND = 0x1C, 413 CEC_DECK_INFO_INDEX_SEARCH_FORWARD = 0x1D, 414 CEC_DECK_INFO_INDEX_SEARCH_REVERSE = 0x1E, 415 CEC_DECK_INFO_OTHER_STATUS = 0x1F, 416 CEC_DECK_INFO_OTHER_STATUS_LG = 0x20 417 } cec_deck_info; 418 419 typedef enum cec_device_type 420 { 421 CEC_DEVICE_TYPE_TV = 0, 422 CEC_DEVICE_TYPE_RECORDING_DEVICE = 1, 423 CEC_DEVICE_TYPE_RESERVED = 2, 424 CEC_DEVICE_TYPE_TUNER = 3, 425 CEC_DEVICE_TYPE_PLAYBACK_DEVICE = 4, 426 CEC_DEVICE_TYPE_AUDIO_SYSTEM = 5 427 } cec_device_type; 428 429 typedef enum cec_display_control 430 { 431 CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME = 0x00, 432 CEC_DISPLAY_CONTROL_DISPLAY_UNTIL_CLEARED = 0x40, 433 CEC_DISPLAY_CONTROL_CLEAR_PREVIOUS_MESSAGE = 0x80, 434 CEC_DISPLAY_CONTROL_RESERVED_FOR_FUTURE_USE = 0xC0 435 } cec_display_control; 436 437 typedef enum cec_external_source_specifier 438 { 439 CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PLUG = 4, 440 CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PHYSICAL_ADDRESS = 5 441 } cec_external_source_specifier; 442 443 typedef enum cec_menu_request_type 444 { 445 CEC_MENU_REQUEST_TYPE_ACTIVATE = 0, 446 CEC_MENU_REQUEST_TYPE_DEACTIVATE = 1, 447 CEC_MENU_REQUEST_TYPE_QUERY = 2 448 } cec_menu_request_type; 449 450 typedef enum cec_menu_state 451 { 452 CEC_MENU_STATE_ACTIVATED = 0, 453 CEC_MENU_STATE_DEACTIVATED = 1 454 } cec_menu_state; 455 456 typedef enum cec_play_mode 457 { 458 CEC_PLAY_MODE_PLAY_FORWARD = 0x24, 459 CEC_PLAY_MODE_PLAY_REVERSE = 0x20, 460 CEC_PLAY_MODE_PLAY_STILL = 0x25, 461 CEC_PLAY_MODE_FAST_FORWARD_MIN_SPEED = 0x05, 462 CEC_PLAY_MODE_FAST_FORWARD_MEDIUM_SPEED = 0x06, 463 CEC_PLAY_MODE_FAST_FORWARD_MAX_SPEED = 0x07, 464 CEC_PLAY_MODE_FAST_REVERSE_MIN_SPEED = 0x09, 465 CEC_PLAY_MODE_FAST_REVERSE_MEDIUM_SPEED = 0x0A, 466 CEC_PLAY_MODE_FAST_REVERSE_MAX_SPEED = 0x0B, 467 CEC_PLAY_MODE_SLOW_FORWARD_MIN_SPEED = 0x15, 468 CEC_PLAY_MODE_SLOW_FORWARD_MEDIUM_SPEED = 0x16, 469 CEC_PLAY_MODE_SLOW_FORWARD_MAX_SPEED = 0x17, 470 CEC_PLAY_MODE_SLOW_REVERSE_MIN_SPEED = 0x19, 471 CEC_PLAY_MODE_SLOW_REVERSE_MEDIUM_SPEED = 0x1A, 472 CEC_PLAY_MODE_SLOW_REVERSE_MAX_SPEED = 0x1B 473 } cec_play_mode; 474 475 typedef enum cec_power_status 476 { 477 CEC_POWER_STATUS_ON = 0x00, 478 CEC_POWER_STATUS_STANDBY = 0x01, 479 CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON = 0x02, 480 CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY = 0x03, 481 CEC_POWER_STATUS_UNKNOWN = 0x99 482 } cec_power_status; 483 484 typedef enum cec_record_source_type 485 { 486 CEC_RECORD_SOURCE_TYPE_OWN_SOURCE = 1, 487 CEC_RECORD_SOURCE_TYPE_DIGITAL_SERVICE = 2, 488 CEC_RECORD_SOURCE_TYPE_ANALOGUE_SERVICE = 3, 489 CEC_RECORD_SOURCE_TYPE_EXTERNAL_PLUS = 4, 490 CEC_RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS = 5 491 } cec_record_source_type; 492 493 typedef enum cec_record_status_info 494 { 495 CEC_RECORD_STATUS_INFO_RECORDING_CURRENTLY_SELECTED_SOURCE = 0x01, 496 CEC_RECORD_STATUS_INFO_RECORDING_DIGITAL_SERVICE = 0x02, 497 CEC_RECORD_STATUS_INFO_RECORDING_ANALOGUE_SERVICE = 0x03, 498 CEC_RECORD_STATUS_INFO_RECORDING_EXTERNAL_INPUT = 0x04, 499 CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_DIGITAL_SERVICE = 0x05, 500 CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_ANALOGUE_SERVICE = 0x06, 501 CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_SELECT_REQUIRED_SERVICE = 0x07, 502 CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_PLUG_NUMBER = 0x09, 503 CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_ADDRESS = 0x0A, 504 CEC_RECORD_STATUS_INFO_NO_RECORDING_CA_SYSTEM_NOT_SUPPORTED = 0x0B, 505 CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_OR_INSUFFICIENT_ENTITLEMENTS = 0x0C, 506 CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ALLOWED_TO_COPY_SOURCE = 0x0D, 507 CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_FURTHER_COPIES_ALLOWED = 0x0E, 508 CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_MEDIA = 0x10, 509 CEC_RECORD_STATUS_INFO_NO_RECORDING_PLAYING = 0x11, 510 CEC_RECORD_STATUS_INFO_NO_RECORDING_ALREADY_RECORDING = 0x12, 511 CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROTECTED = 0x13, 512 CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_SOURCE_SIGNAL = 0x14, 513 CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROBLEM = 0x15, 514 CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ENOUGH_SPACE_AVAILABLE = 0x16, 515 CEC_RECORD_STATUS_INFO_NO_RECORDING_PARENTAL_LOCK_ON = 0x17, 516 CEC_RECORD_STATUS_INFO_RECORDING_TERMINATED_NORMALLY = 0x1A, 517 CEC_RECORD_STATUS_INFO_RECORDING_HAS_ALREADY_TERMINATED = 0x1B, 518 CEC_RECORD_STATUS_INFO_NO_RECORDING_OTHER_REASON = 0x1F 519 } cec_record_status_info; 520 521 typedef enum cec_recording_sequence 522 { 523 CEC_RECORDING_SEQUENCE_SUNDAY = 0x01, 524 CEC_RECORDING_SEQUENCE_MONDAY = 0x02, 525 CEC_RECORDING_SEQUENCE_TUESDAY = 0x04, 526 CEC_RECORDING_SEQUENCE_WEDNESDAY = 0x08, 527 CEC_RECORDING_SEQUENCE_THURSDAY = 0x10, 528 CEC_RECORDING_SEQUENCE_FRIDAY = 0x20, 529 CEC_RECORDING_SEQUENCE_SATURDAY = 0x40, 530 CEC_RECORDING_SEQUENCE_ONCE_ONLY = 0x00 531 } cec_recording_sequence; 532 533 typedef enum cec_status_request 534 { 535 CEC_STATUS_REQUEST_ON = 1, 536 CEC_STATUS_REQUEST_OFF = 2, 537 CEC_STATUS_REQUEST_ONCE = 3 538 } cec_status_request; 539 540 typedef enum cec_system_audio_status 541 { 542 CEC_SYSTEM_AUDIO_STATUS_OFF = 0, 543 CEC_SYSTEM_AUDIO_STATUS_ON = 1 544 } cec_system_audio_status; 545 546 typedef enum cec_timer_cleared_status_data 547 { 548 CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_RECORDING = 0x00, 549 CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_MATCHING = 0x01, 550 CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_INF0_AVAILABLE = 0x02, 551 CEC_TIMER_CLEARED_STATUS_DATA_TIMER_CLEARED = 0x80 552 } cec_timer_cleared_status_data; 553 554 typedef enum cec_timer_overlap_warning 555 { 556 CEC_TIMER_OVERLAP_WARNING_NO_OVERLAP = 0, 557 CEC_TIMER_OVERLAP_WARNING_TIMER_BLOCKS_OVERLAP = 1 558 } cec_timer_overlap_warning; 559 560 typedef enum cec_media_info 561 { 562 CEC_MEDIA_INFO_MEDIA_PRESENT_AND_NOT_PROTECTED = 0x00, 563 CEC_MEDIA_INFO_MEDIA_PRESENT_BUT_PROTECTED = 0x01, 564 CEC_MEDIA_INFO_MEDIA_NOT_PRESENT = 0x02, 565 CEC_MEDIA_INFO_FUTURE_USE = 0x03 566 } cec_media_info; 567 568 typedef enum cec_programmed_indicator 569 { 570 CEC_PROGRAMMED_INDICATOR_NOT_PROGRAMMED = 0, 571 CEC_PROGRAMMED_INDICATOR_PROGRAMMED = 1 572 } cec_programmed_indicator; 573 574 typedef enum cec_programmed_info 575 { 576 CEC_PROGRAMMED_INFO_FUTURE_USE = 0x0, 577 CEC_PROGRAMMED_INFO_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING = 0x08, 578 CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING = 0x09, 579 CEC_PROGRAMMED_INFO_MAY_NOT_BE_ENOUGH_SPACE_AVAILABLE = 0x0B, 580 CEC_PROGRAMMED_INFO_NO_MEDIA_INFO_AVAILABLE = 0x0A 581 } cec_programmed_info; 582 583 typedef enum cec_not_programmed_error_info 584 { 585 CEC_NOT_PROGRAMMED_ERROR_INFO_FUTURE_USE = 0x0, 586 CEC_NOT_PROGRAMMED_ERROR_INFO_NO_FREE_TIMER_AVAILABLE = 0x01, 587 CEC_NOT_PROGRAMMED_ERROR_INFO_DATE_OUT_OF_RANGE = 0x02, 588 CEC_NOT_PROGRAMMED_ERROR_INFO_RECORDING_SEQUENCE_ERROR = 0x03, 589 CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PLUG_NUMBER = 0x04, 590 CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PHYSICAL_ADDRESS = 0x05, 591 CEC_NOT_PROGRAMMED_ERROR_INFO_CA_SYSTEM_NOT_SUPPORTED = 0x06, 592 CEC_NOT_PROGRAMMED_ERROR_INFO_NO_OR_INSUFFICIENT_CA_ENTITLEMENTS = 0x07, 593 CEC_NOT_PROGRAMMED_ERROR_INFO_DOES_NOT_SUPPORT_RESOLUTION = 0x08, 594 CEC_NOT_PROGRAMMED_ERROR_INFO_PARENTAL_LOCK_ON = 0x09, 595 CEC_NOT_PROGRAMMED_ERROR_INFO_CLOCK_FAILURE = 0x0A, 596 CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_START = 0x0B, 597 CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_END = 0x0D, 598 CEC_NOT_PROGRAMMED_ERROR_INFO_DUPLICATE_ALREADY_PROGRAMMED = 0x0E 599 } cec_not_programmed_error_info; 600 601 typedef enum cec_recording_flag 602 { 603 CEC_RECORDING_FLAG_NOT_BEING_USED_FOR_RECORDING = 0, 604 CEC_RECORDING_FLAG_BEING_USED_FOR_RECORDING = 1 605 } cec_recording_flag; 606 607 typedef enum cec_tuner_display_info 608 { 609 CEC_TUNER_DISPLAY_INFO_DISPLAYING_DIGITAL_TUNER = 0, 610 CEC_TUNER_DISPLAY_INFO_NOT_DISPLAYING_TUNER = 1, 611 CEC_TUNER_DISPLAY_INFO_DISPLAYING_ANALOGUE_TUNER = 2 612 } cec_tuner_display_info; 613 614 typedef enum cec_broadcast_system 615 { 616 CEC_BROADCAST_SYSTEM_PAL_B_G = 0, 617 CEC_BROADCAST_SYSTEM_SECAM_L1 = 1, 618 CEC_BROADCAST_SYSTEM_PAL_M = 2, 619 CEC_BROADCAST_SYSTEM_NTSC_M = 3, 620 CEC_BROADCAST_SYSTEM_PAL_I = 4, 621 CEC_BROADCAST_SYSTEM_SECAM_DK = 5, 622 CEC_BROADCAST_SYSTEM_SECAM_B_G = 6, 623 CEC_BROADCAST_SYSTEM_SECAM_L2 = 7, 624 CEC_BROADCAST_SYSTEM_PAL_DK = 8, 625 CEC_BROADCAST_SYSTEM_OTHER_SYSTEM = 30 626 } cec_broadcast_system; 627 628 typedef enum cec_user_control_code 629 { 630 CEC_USER_CONTROL_CODE_SELECT = 0x00, 631 CEC_USER_CONTROL_CODE_UP = 0x01, 632 CEC_USER_CONTROL_CODE_DOWN = 0x02, 633 CEC_USER_CONTROL_CODE_LEFT = 0x03, 634 CEC_USER_CONTROL_CODE_RIGHT = 0x04, 635 CEC_USER_CONTROL_CODE_RIGHT_UP = 0x05, 636 CEC_USER_CONTROL_CODE_RIGHT_DOWN = 0x06, 637 CEC_USER_CONTROL_CODE_LEFT_UP = 0x07, 638 CEC_USER_CONTROL_CODE_LEFT_DOWN = 0x08, 639 CEC_USER_CONTROL_CODE_ROOT_MENU = 0x09, 640 CEC_USER_CONTROL_CODE_SETUP_MENU = 0x0A, 641 CEC_USER_CONTROL_CODE_CONTENTS_MENU = 0x0B, 642 CEC_USER_CONTROL_CODE_FAVORITE_MENU = 0x0C, 643 CEC_USER_CONTROL_CODE_EXIT = 0x0D, 644 // reserved: 0x0E, 0x0F 645 CEC_USER_CONTROL_CODE_TOP_MENU = 0x10, 646 CEC_USER_CONTROL_CODE_DVD_MENU = 0x11, 647 // reserved: 0x12 ... 0x1C 648 CEC_USER_CONTROL_CODE_NUMBER_ENTRY_MODE = 0x1D, 649 CEC_USER_CONTROL_CODE_NUMBER11 = 0x1E, 650 CEC_USER_CONTROL_CODE_NUMBER12 = 0x1F, 651 CEC_USER_CONTROL_CODE_NUMBER0 = 0x20, 652 CEC_USER_CONTROL_CODE_NUMBER1 = 0x21, 653 CEC_USER_CONTROL_CODE_NUMBER2 = 0x22, 654 CEC_USER_CONTROL_CODE_NUMBER3 = 0x23, 655 CEC_USER_CONTROL_CODE_NUMBER4 = 0x24, 656 CEC_USER_CONTROL_CODE_NUMBER5 = 0x25, 657 CEC_USER_CONTROL_CODE_NUMBER6 = 0x26, 658 CEC_USER_CONTROL_CODE_NUMBER7 = 0x27, 659 CEC_USER_CONTROL_CODE_NUMBER8 = 0x28, 660 CEC_USER_CONTROL_CODE_NUMBER9 = 0x29, 661 CEC_USER_CONTROL_CODE_DOT = 0x2A, 662 CEC_USER_CONTROL_CODE_ENTER = 0x2B, 663 CEC_USER_CONTROL_CODE_CLEAR = 0x2C, 664 CEC_USER_CONTROL_CODE_NEXT_FAVORITE = 0x2F, 665 CEC_USER_CONTROL_CODE_CHANNEL_UP = 0x30, 666 CEC_USER_CONTROL_CODE_CHANNEL_DOWN = 0x31, 667 CEC_USER_CONTROL_CODE_PREVIOUS_CHANNEL = 0x32, 668 CEC_USER_CONTROL_CODE_SOUND_SELECT = 0x33, 669 CEC_USER_CONTROL_CODE_INPUT_SELECT = 0x34, 670 CEC_USER_CONTROL_CODE_DISPLAY_INFORMATION = 0x35, 671 CEC_USER_CONTROL_CODE_HELP = 0x36, 672 CEC_USER_CONTROL_CODE_PAGE_UP = 0x37, 673 CEC_USER_CONTROL_CODE_PAGE_DOWN = 0x38, 674 // reserved: 0x39 ... 0x3F 675 CEC_USER_CONTROL_CODE_POWER = 0x40, 676 CEC_USER_CONTROL_CODE_VOLUME_UP = 0x41, 677 CEC_USER_CONTROL_CODE_VOLUME_DOWN = 0x42, 678 CEC_USER_CONTROL_CODE_MUTE = 0x43, 679 CEC_USER_CONTROL_CODE_PLAY = 0x44, 680 CEC_USER_CONTROL_CODE_STOP = 0x45, 681 CEC_USER_CONTROL_CODE_PAUSE = 0x46, 682 CEC_USER_CONTROL_CODE_RECORD = 0x47, 683 CEC_USER_CONTROL_CODE_REWIND = 0x48, 684 CEC_USER_CONTROL_CODE_FAST_FORWARD = 0x49, 685 CEC_USER_CONTROL_CODE_EJECT = 0x4A, 686 CEC_USER_CONTROL_CODE_FORWARD = 0x4B, 687 CEC_USER_CONTROL_CODE_BACKWARD = 0x4C, 688 CEC_USER_CONTROL_CODE_STOP_RECORD = 0x4D, 689 CEC_USER_CONTROL_CODE_PAUSE_RECORD = 0x4E, 690 // reserved: 0x4F 691 CEC_USER_CONTROL_CODE_ANGLE = 0x50, 692 CEC_USER_CONTROL_CODE_SUB_PICTURE = 0x51, 693 CEC_USER_CONTROL_CODE_VIDEO_ON_DEMAND = 0x52, 694 CEC_USER_CONTROL_CODE_ELECTRONIC_PROGRAM_GUIDE = 0x53, 695 CEC_USER_CONTROL_CODE_TIMER_PROGRAMMING = 0x54, 696 CEC_USER_CONTROL_CODE_INITIAL_CONFIGURATION = 0x55, 697 CEC_USER_CONTROL_CODE_SELECT_BROADCAST_TYPE = 0x56, 698 CEC_USER_CONTROL_CODE_SELECT_SOUND_PRESENTATION = 0x57, 699 // reserved: 0x58 ... 0x5F 700 CEC_USER_CONTROL_CODE_PLAY_FUNCTION = 0x60, 701 CEC_USER_CONTROL_CODE_PAUSE_PLAY_FUNCTION = 0x61, 702 CEC_USER_CONTROL_CODE_RECORD_FUNCTION = 0x62, 703 CEC_USER_CONTROL_CODE_PAUSE_RECORD_FUNCTION = 0x63, 704 CEC_USER_CONTROL_CODE_STOP_FUNCTION = 0x64, 705 CEC_USER_CONTROL_CODE_MUTE_FUNCTION = 0x65, 706 CEC_USER_CONTROL_CODE_RESTORE_VOLUME_FUNCTION = 0x66, 707 CEC_USER_CONTROL_CODE_TUNE_FUNCTION = 0x67, 708 CEC_USER_CONTROL_CODE_SELECT_MEDIA_FUNCTION = 0x68, 709 CEC_USER_CONTROL_CODE_SELECT_AV_INPUT_FUNCTION = 0x69, 710 CEC_USER_CONTROL_CODE_SELECT_AUDIO_INPUT_FUNCTION = 0x6A, 711 CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION = 0x6B, 712 CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION = 0x6C, 713 CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION = 0x6D, 714 // reserved: 0x6E ... 0x70 715 CEC_USER_CONTROL_CODE_F1_BLUE = 0x71, 716 CEC_USER_CONTROL_CODE_F2_RED = 0X72, 717 CEC_USER_CONTROL_CODE_F3_GREEN = 0x73, 718 CEC_USER_CONTROL_CODE_F4_YELLOW = 0x74, 719 CEC_USER_CONTROL_CODE_F5 = 0x75, 720 CEC_USER_CONTROL_CODE_DATA = 0x76, 721 // reserved: 0x77 ... 0xFF 722 CEC_USER_CONTROL_CODE_AN_RETURN = 0x91, // return (Samsung) 723 CEC_USER_CONTROL_CODE_AN_CHANNELS_LIST = 0x96, // channels list (Samsung) 724 CEC_USER_CONTROL_CODE_MAX = 0x96, 725 CEC_USER_CONTROL_CODE_UNKNOWN = 0xFF 726 } cec_user_control_code; 727 728 typedef enum cec_logical_address 729 { 730 CECDEVICE_UNKNOWN = -1, //not a valid logical address 731 CECDEVICE_TV = 0, 732 CECDEVICE_RECORDINGDEVICE1 = 1, 733 CECDEVICE_RECORDINGDEVICE2 = 2, 734 CECDEVICE_TUNER1 = 3, 735 CECDEVICE_PLAYBACKDEVICE1 = 4, 736 CECDEVICE_AUDIOSYSTEM = 5, 737 CECDEVICE_TUNER2 = 6, 738 CECDEVICE_TUNER3 = 7, 739 CECDEVICE_PLAYBACKDEVICE2 = 8, 740 CECDEVICE_RECORDINGDEVICE3 = 9, 741 CECDEVICE_TUNER4 = 10, 742 CECDEVICE_PLAYBACKDEVICE3 = 11, 743 CECDEVICE_RESERVED1 = 12, 744 CECDEVICE_RESERVED2 = 13, 745 CECDEVICE_FREEUSE = 14, 746 CECDEVICE_UNREGISTERED = 15, 747 CECDEVICE_BROADCAST = 15 748 } cec_logical_address; 749 750 typedef enum cec_opcode 751 { 752 CEC_OPCODE_ACTIVE_SOURCE = 0x82, 753 CEC_OPCODE_IMAGE_VIEW_ON = 0x04, 754 CEC_OPCODE_TEXT_VIEW_ON = 0x0D, 755 CEC_OPCODE_INACTIVE_SOURCE = 0x9D, 756 CEC_OPCODE_REQUEST_ACTIVE_SOURCE = 0x85, 757 CEC_OPCODE_ROUTING_CHANGE = 0x80, 758 CEC_OPCODE_ROUTING_INFORMATION = 0x81, 759 CEC_OPCODE_SET_STREAM_PATH = 0x86, 760 CEC_OPCODE_STANDBY = 0x36, 761 CEC_OPCODE_RECORD_OFF = 0x0B, 762 CEC_OPCODE_RECORD_ON = 0x09, 763 CEC_OPCODE_RECORD_STATUS = 0x0A, 764 CEC_OPCODE_RECORD_TV_SCREEN = 0x0F, 765 CEC_OPCODE_CLEAR_ANALOGUE_TIMER = 0x33, 766 CEC_OPCODE_CLEAR_DIGITAL_TIMER = 0x99, 767 CEC_OPCODE_CLEAR_EXTERNAL_TIMER = 0xA1, 768 CEC_OPCODE_SET_ANALOGUE_TIMER = 0x34, 769 CEC_OPCODE_SET_DIGITAL_TIMER = 0x97, 770 CEC_OPCODE_SET_EXTERNAL_TIMER = 0xA2, 771 CEC_OPCODE_SET_TIMER_PROGRAM_TITLE = 0x67, 772 CEC_OPCODE_TIMER_CLEARED_STATUS = 0x43, 773 CEC_OPCODE_TIMER_STATUS = 0x35, 774 CEC_OPCODE_CEC_VERSION = 0x9E, 775 CEC_OPCODE_GET_CEC_VERSION = 0x9F, 776 CEC_OPCODE_GIVE_PHYSICAL_ADDRESS = 0x83, 777 CEC_OPCODE_GET_MENU_LANGUAGE = 0x91, 778 CEC_OPCODE_REPORT_PHYSICAL_ADDRESS = 0x84, 779 CEC_OPCODE_SET_MENU_LANGUAGE = 0x32, 780 CEC_OPCODE_DECK_CONTROL = 0x42, 781 CEC_OPCODE_DECK_STATUS = 0x1B, 782 CEC_OPCODE_GIVE_DECK_STATUS = 0x1A, 783 CEC_OPCODE_PLAY = 0x41, 784 CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS = 0x08, 785 CEC_OPCODE_SELECT_ANALOGUE_SERVICE = 0x92, 786 CEC_OPCODE_SELECT_DIGITAL_SERVICE = 0x93, 787 CEC_OPCODE_TUNER_DEVICE_STATUS = 0x07, 788 CEC_OPCODE_TUNER_STEP_DECREMENT = 0x06, 789 CEC_OPCODE_TUNER_STEP_INCREMENT = 0x05, 790 CEC_OPCODE_DEVICE_VENDOR_ID = 0x87, 791 CEC_OPCODE_GIVE_DEVICE_VENDOR_ID = 0x8C, 792 CEC_OPCODE_VENDOR_COMMAND = 0x89, 793 CEC_OPCODE_VENDOR_COMMAND_WITH_ID = 0xA0, 794 CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN = 0x8A, 795 CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP = 0x8B, 796 CEC_OPCODE_SET_OSD_STRING = 0x64, 797 CEC_OPCODE_GIVE_OSD_NAME = 0x46, 798 CEC_OPCODE_SET_OSD_NAME = 0x47, 799 CEC_OPCODE_MENU_REQUEST = 0x8D, 800 CEC_OPCODE_MENU_STATUS = 0x8E, 801 CEC_OPCODE_USER_CONTROL_PRESSED = 0x44, 802 CEC_OPCODE_USER_CONTROL_RELEASE = 0x45, 803 CEC_OPCODE_GIVE_DEVICE_POWER_STATUS = 0x8F, 804 CEC_OPCODE_REPORT_POWER_STATUS = 0x90, 805 CEC_OPCODE_FEATURE_ABORT = 0x00, 806 CEC_OPCODE_ABORT = 0xFF, 807 CEC_OPCODE_GIVE_AUDIO_STATUS = 0x71, 808 CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS = 0x7D, 809 CEC_OPCODE_REPORT_AUDIO_STATUS = 0x7A, 810 CEC_OPCODE_SET_SYSTEM_AUDIO_MODE = 0x72, 811 CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST = 0x70, 812 CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS = 0x7E, 813 CEC_OPCODE_SET_AUDIO_RATE = 0x9A, 814 815 /* CEC 1.4 */ 816 CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTORS = 0xA3, 817 CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTORS = 0xA4, 818 CEC_OPCODE_START_ARC = 0xC0, 819 CEC_OPCODE_REPORT_ARC_STARTED = 0xC1, 820 CEC_OPCODE_REPORT_ARC_ENDED = 0xC2, 821 CEC_OPCODE_REQUEST_ARC_START = 0xC3, 822 CEC_OPCODE_REQUEST_ARC_END = 0xC4, 823 CEC_OPCODE_END_ARC = 0xC5, 824 CEC_OPCODE_CDC = 0xF8, 825 /* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */ 826 CEC_OPCODE_NONE = 0xFD 827 } cec_opcode; 828 829 typedef enum cec_log_level 830 { 831 CEC_LOG_ERROR = 1, 832 CEC_LOG_WARNING = 2, 833 CEC_LOG_NOTICE = 4, 834 CEC_LOG_TRAFFIC = 8, 835 CEC_LOG_DEBUG = 16, 836 CEC_LOG_ALL = 31 837 } cec_log_level; 838 839 typedef enum cec_bus_device_status 840 { 841 CEC_DEVICE_STATUS_UNKNOWN, 842 CEC_DEVICE_STATUS_PRESENT, 843 CEC_DEVICE_STATUS_NOT_PRESENT, 844 CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC 845 } cec_bus_device_status; 846 847 typedef enum cec_vendor_id 848 { 849 CEC_VENDOR_TOSHIBA = 0x000039, 850 CEC_VENDOR_SAMSUNG = 0x0000F0, 851 CEC_VENDOR_DENON = 0x0005CD, 852 CEC_VENDOR_MARANTZ = 0x000678, 853 CEC_VENDOR_LOEWE = 0x000982, 854 CEC_VENDOR_ONKYO = 0x0009B0, 855 CEC_VENDOR_MEDION = 0x000CB8, 856 CEC_VENDOR_TOSHIBA2 = 0x000CE7, 857 CEC_VENDOR_APPLE = 0x0010FA, 858 CEC_VENDOR_PULSE_EIGHT = 0x001582, 859 CEC_VENDOR_HARMAN_KARDON2 = 0x001950, 860 CEC_VENDOR_GOOGLE = 0x001A11, 861 CEC_VENDOR_AKAI = 0x0020C7, 862 CEC_VENDOR_AOC = 0x002467, 863 CEC_VENDOR_PANASONIC = 0x008045, 864 CEC_VENDOR_PHILIPS = 0x00903E, 865 CEC_VENDOR_DAEWOO = 0x009053, 866 CEC_VENDOR_YAMAHA = 0x00A0DE, 867 CEC_VENDOR_GRUNDIG = 0x00D0D5, 868 CEC_VENDOR_PIONEER = 0x00E036, 869 CEC_VENDOR_LG = 0x00E091, 870 CEC_VENDOR_SHARP = 0x08001F, 871 CEC_VENDOR_SONY = 0x080046, 872 CEC_VENDOR_BROADCOM = 0x18C086, 873 CEC_VENDOR_SHARP2 = 0x534850, 874 CEC_VENDOR_VIZIO = 0x6B746D, 875 CEC_VENDOR_BENQ = 0x8065E9, 876 CEC_VENDOR_HARMAN_KARDON = 0x9C645E, 877 CEC_VENDOR_UNKNOWN = 0 878 } cec_vendor_id; 879 880 typedef enum cec_adapter_type 881 { 882 ADAPTERTYPE_UNKNOWN = 0, 883 ADAPTERTYPE_P8_EXTERNAL = 0x1, 884 ADAPTERTYPE_P8_DAUGHTERBOARD = 0x2, 885 ADAPTERTYPE_RPI = 0x100, 886 ADAPTERTYPE_TDA995x = 0x200, 887 ADAPTERTYPE_EXYNOS = 0x300, 888 ADAPTERTYPE_LINUX = 0x400, 889 ADAPTERTYPE_AOCEC = 0x500, 890 ADAPTERTYPE_IMX = 0x600 891 } cec_adapter_type; 892 893 /** force exporting through swig */ 894 enum libcec_version 895 { 896 LIBCEC_VERSION_CURRENT = _LIBCEC_VERSION_CURRENT 897 }; 898 899 typedef char cec_menu_language[4]; /**< the iso language code + (char)0 */ 900 typedef char cec_osd_name[14]; /**< the name of the device */ 901 902 typedef struct cec_log_message 903 { 904 const char* message; /**< the actual message, valid until returning from the log callback */ 905 cec_log_level level; /**< log level of the message */ 906 int64_t time; /**< the timestamp of this message */ 907 } cec_log_message; 908 909 typedef struct cec_keypress 910 { 911 cec_user_control_code keycode; /**< the keycode */ 912 unsigned int duration; /**< the duration of the keypress */ 913 } cec_keypress; 914 915 typedef struct cec_adapter 916 { 917 char path[1024]; /**< the path to the com port */ 918 char comm[1024]; /**< the name of the com port */ 919 } cec_adapter; 920 921 typedef struct cec_adapter_descriptor 922 { 923 char strComPath[1024]; /**< the path to the com port */ 924 char strComName[1024]; /**< the name of the com port */ 925 uint16_t iVendorId; 926 uint16_t iProductId; 927 uint16_t iFirmwareVersion; 928 uint16_t iPhysicalAddress; 929 uint32_t iFirmwareBuildDate; 930 cec_adapter_type adapterType; 931 } cec_adapter_descriptor; 932 933 #if defined(__cplusplus) 934 typedef struct AdapterDescriptor 935 { AdapterDescriptorAdapterDescriptor936 AdapterDescriptor(void) : 937 iVendorId(0), 938 iProductId(0), 939 iFirmwareVersion(0), 940 iPhysicalAddress(0), 941 iFirmwareBuildDate(0), 942 adapterType(ADAPTERTYPE_UNKNOWN) 943 { 944 } 945 AdapterDescriptorAdapterDescriptor946 AdapterDescriptor(const cec_adapter_descriptor& other) 947 { 948 strComPath = other.strComPath; 949 strComName = other.strComName; 950 iVendorId = other.iVendorId; 951 iProductId = other.iProductId; 952 iFirmwareVersion = other.iFirmwareVersion; 953 iPhysicalAddress = other.iPhysicalAddress; 954 iFirmwareBuildDate = other.iFirmwareBuildDate; 955 adapterType = other.adapterType; 956 } 957 958 std::string strComPath; /**< the path to the com port */ 959 std::string strComName; /**< the name of the com port */ 960 uint16_t iVendorId; 961 uint16_t iProductId; 962 uint16_t iFirmwareVersion; 963 uint16_t iPhysicalAddress; 964 uint32_t iFirmwareBuildDate; 965 cec_adapter_type adapterType; 966 } AdapterDescriptor; 967 #endif 968 969 typedef struct cec_datapacket 970 { 971 uint8_t data[CEC_MAX_DATA_PACKET_SIZE]; /**< the actual data */ 972 uint8_t size; /**< the size of the data */ 973 974 #ifdef __cplusplus 975 cec_datapacket &operator =(const struct cec_datapacket &packet) 976 { 977 Clear(); 978 for (uint8_t iPtr = 0; iPtr < packet.size; iPtr++) 979 PushBack(packet[iPtr]); 980 981 return *this; 982 } 983 984 bool operator ==(const struct cec_datapacket& packet) const 985 { 986 if (size != packet.size) 987 return false; 988 for (uint8_t iPtr = 0; iPtr < size; iPtr++) 989 if (packet.data[iPtr] != data[iPtr]) 990 return false; 991 return true; 992 } 993 994 /** @return True when this packet is empty, false otherwise. */ IsEmptycec_datapacket995 bool IsEmpty(void) const { return size == 0; } 996 /** @return True when this packet is false, false otherwise. */ IsFullcec_datapacket997 bool IsFull(void) const { return size == CEC_MAX_DATA_PACKET_SIZE; } 998 999 /*! 1000 * @brief Get the byte at the requested position. 1001 * @param pos The position. 1002 * @return The byte, or 0 when out of bounds. 1003 */ 1004 uint8_t operator[](uint8_t pos) const { return pos < size ? data[pos] : 0; } 1005 /*! 1006 * @brief Get the byte at the requested position. 1007 * @param pos The position. 1008 * @return The byte, or 0 when out of bounds. 1009 */ Atcec_datapacket1010 uint8_t At(uint8_t pos) const { return pos < size ? data[pos] : 0; } 1011 1012 /*! 1013 * @brief Shift the contents of this packet. 1014 * @param iShiftBy The number of positions to shift. 1015 */ Shiftcec_datapacket1016 void Shift(uint8_t iShiftBy) 1017 { 1018 if (iShiftBy >= size) 1019 { 1020 Clear(); 1021 } 1022 else 1023 { 1024 for (uint8_t iPtr = 0; iPtr < size; iPtr++) 1025 data[iPtr] = (iPtr + iShiftBy < size) ? data[iPtr + iShiftBy] : 0; 1026 size = (uint8_t) (size - iShiftBy); 1027 } 1028 } 1029 1030 /*! 1031 * @brief Push a byte to the end of this packet. 1032 * @param add The byte to add. 1033 */ PushBackcec_datapacket1034 void PushBack(uint8_t add) 1035 { 1036 if (size < CEC_MAX_DATA_PACKET_SIZE) 1037 data[size++] = add; 1038 } 1039 1040 /*! 1041 * @brief Clear this packet. 1042 */ Clearcec_datapacket1043 void Clear(void) 1044 { 1045 memset(data, 0, sizeof(data)); 1046 size = 0; 1047 } 1048 #endif 1049 1050 } cec_datapacket; 1051 1052 typedef struct cec_command 1053 { 1054 cec_logical_address initiator; /**< the logical address of the initiator of this message */ 1055 cec_logical_address destination; /**< the logical address of the destination of this message */ 1056 int8_t ack; /**< 1 when the ACK bit is set, 0 otherwise */ 1057 int8_t eom; /**< 1 when the EOM bit is set, 0 otherwise */ 1058 cec_opcode opcode; /**< the opcode of this message */ 1059 cec_datapacket parameters; /**< the parameters attached to this message */ 1060 int8_t opcode_set; /**< 1 when an opcode is set, 0 otherwise (POLL message) */ 1061 int32_t transmit_timeout; /**< the timeout to use in ms */ 1062 1063 #ifdef __cplusplus cec_commandcec_command1064 cec_command(void) 1065 { 1066 Clear(); 1067 } 1068 1069 cec_command &operator =(const struct cec_command &command) 1070 { 1071 initiator = command.initiator; 1072 destination = command.destination; 1073 ack = command.ack; 1074 eom = command.eom; 1075 opcode = command.opcode; 1076 opcode_set = command.opcode_set; 1077 transmit_timeout = command.transmit_timeout; 1078 parameters = command.parameters; 1079 1080 return *this; 1081 } 1082 Sizecec_command1083 uint8_t Size(void) const 1084 { 1085 return parameters.size + opcode_set + 1; 1086 } 1087 1088 /*! 1089 * @brief Formats a cec_command. 1090 * @param command The command to format. 1091 * @param initiator The logical address of the initiator. 1092 * @param destination The logical address of the destination. 1093 * @param opcode The opcode of the command. 1094 * @param timeout The transmission timeout. 1095 */ 1096 static void Format(cec_command &command, cec_logical_address initiator, cec_logical_address destination, cec_opcode opcode, int32_t timeout = CEC_DEFAULT_TRANSMIT_TIMEOUT) 1097 { 1098 command.Clear(); 1099 command.initiator = initiator; 1100 command.destination = destination; 1101 command.transmit_timeout = timeout; 1102 if (opcode != CEC_OPCODE_NONE) 1103 { 1104 command.opcode = opcode; 1105 command.opcode_set = 1; 1106 } 1107 } 1108 1109 /*! 1110 * @brief Push a byte to the back of this command. 1111 * @param data The byte to push. 1112 */ PushBackcec_command1113 void PushBack(uint8_t data) 1114 { 1115 if (initiator == CECDEVICE_UNKNOWN && destination == CECDEVICE_UNKNOWN) 1116 { 1117 initiator = (cec_logical_address) (data >> 4); 1118 destination = (cec_logical_address) (data & 0xF); 1119 } 1120 else if (!opcode_set) 1121 { 1122 opcode_set = 1; 1123 opcode = (cec_opcode) data; 1124 } 1125 else 1126 parameters.PushBack(data); 1127 } 1128 1129 /*! 1130 * @brief Clear this command, resetting everything to the default values. 1131 */ Clearcec_command1132 void Clear(void) 1133 { 1134 initiator = CECDEVICE_UNKNOWN; 1135 destination = CECDEVICE_UNKNOWN; 1136 ack = 0; 1137 eom = 0; 1138 opcode_set = 0; 1139 opcode = CEC_OPCODE_FEATURE_ABORT; 1140 transmit_timeout = CEC_DEFAULT_TRANSMIT_TIMEOUT; 1141 parameters.Clear(); 1142 }; 1143 GetResponseOpcodecec_command1144 static cec_opcode GetResponseOpcode(cec_opcode opcode) 1145 { 1146 switch (opcode) 1147 { 1148 case CEC_OPCODE_REQUEST_ACTIVE_SOURCE: 1149 return CEC_OPCODE_ACTIVE_SOURCE; 1150 case CEC_OPCODE_GET_CEC_VERSION: 1151 return CEC_OPCODE_CEC_VERSION; 1152 case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: 1153 return CEC_OPCODE_REPORT_PHYSICAL_ADDRESS; 1154 case CEC_OPCODE_GET_MENU_LANGUAGE: 1155 return CEC_OPCODE_SET_MENU_LANGUAGE; 1156 case CEC_OPCODE_GIVE_DECK_STATUS: 1157 return CEC_OPCODE_DECK_STATUS; 1158 case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS: 1159 return CEC_OPCODE_TUNER_DEVICE_STATUS; 1160 case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID: 1161 return CEC_OPCODE_DEVICE_VENDOR_ID; 1162 case CEC_OPCODE_GIVE_OSD_NAME: 1163 return CEC_OPCODE_SET_OSD_NAME; 1164 case CEC_OPCODE_MENU_REQUEST: 1165 return CEC_OPCODE_MENU_STATUS; 1166 case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS: 1167 return CEC_OPCODE_REPORT_POWER_STATUS; 1168 case CEC_OPCODE_GIVE_AUDIO_STATUS: 1169 return CEC_OPCODE_REPORT_AUDIO_STATUS; 1170 case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS: 1171 return CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS; 1172 case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST: 1173 return CEC_OPCODE_SET_SYSTEM_AUDIO_MODE; 1174 default: 1175 break; 1176 } 1177 1178 return CEC_OPCODE_NONE; 1179 } 1180 PushArraycec_command1181 void PushArray(size_t len, const uint8_t *data) 1182 { 1183 for (size_t iPtr = 0; iPtr < len; iPtr++) 1184 PushBack(data[iPtr]); 1185 } 1186 #endif 1187 } cec_command; 1188 1189 typedef struct cec_device_type_list 1190 { 1191 cec_device_type types[5]; /**< the list of device types */ 1192 1193 #ifdef __cplusplus 1194 /*! 1195 * @brief Clear this list. 1196 */ Clearcec_device_type_list1197 void Clear(void) 1198 { 1199 for (unsigned int iPtr = 0; iPtr < 5; iPtr++) 1200 types[iPtr] = CEC_DEVICE_TYPE_RESERVED; 1201 } 1202 1203 /*! 1204 * @brief Add a type to this list. 1205 * @param type The type to add. 1206 */ Addcec_device_type_list1207 void Add(const cec_device_type type) 1208 { 1209 for (unsigned int iPtr = 0; iPtr < 5; iPtr++) 1210 { 1211 if (types[iPtr] == CEC_DEVICE_TYPE_RESERVED) 1212 { 1213 types[iPtr] = type; 1214 break; 1215 } 1216 } 1217 } 1218 1219 /*! 1220 * @brief Check whether a type is set in this list. 1221 * @param type The type to check. 1222 * @return True when set, false otherwise. 1223 */ IsSetcec_device_type_list1224 bool IsSet(cec_device_type type) 1225 { 1226 bool bReturn(false); 1227 for (unsigned int iPtr = 0; !bReturn && iPtr < 5; iPtr++) 1228 { 1229 if (types[iPtr] == type) 1230 bReturn = true; 1231 } 1232 return bReturn; 1233 } 1234 1235 /*! 1236 * @return True when this list is empty, false otherwise. 1237 */ IsEmptycec_device_type_list1238 bool IsEmpty() const 1239 { 1240 bool bReturn(true); 1241 for (unsigned int iPtr = 0; bReturn && iPtr < 5; iPtr++) 1242 { 1243 if (types[iPtr] != CEC_DEVICE_TYPE_RESERVED) 1244 bReturn = false; 1245 } 1246 return bReturn; 1247 } 1248 1249 /*! 1250 * @brief Get the type at the requested position. 1251 * @param pos The position. 1252 * @return The type, or CEC_DEVICE_TYPE_RESERVED when out of bounds. 1253 */ 1254 cec_device_type operator[](uint8_t pos) const { return pos < 5 ? types[pos] : CEC_DEVICE_TYPE_RESERVED; } 1255 1256 bool operator==(const cec_device_type_list &other) const 1257 { 1258 bool bEqual(true); 1259 for (uint8_t iPtr = 0; iPtr < 5; iPtr++) 1260 bEqual &= (types[iPtr] == other[iPtr]); 1261 return bEqual; 1262 } 1263 1264 bool operator!=(const cec_device_type_list &other) const 1265 { 1266 return !(*this == other); 1267 } 1268 #endif 1269 } cec_device_type_list; 1270 1271 typedef struct cec_logical_addresses 1272 { 1273 cec_logical_address primary; /**< the primary logical address to use */ 1274 int addresses[16]; /**< the list of addresses */ 1275 1276 #ifdef __cplusplus 1277 /*! 1278 * @brief Clear this list. 1279 */ Clearcec_logical_addresses1280 void Clear(void) 1281 { 1282 primary = CECDEVICE_UNREGISTERED; 1283 for (unsigned int iPtr = 0; iPtr < 16; iPtr++) 1284 addresses[iPtr] = 0; 1285 } 1286 1287 /*! 1288 * @return True when empty, false otherwise. 1289 */ IsEmptycec_logical_addresses1290 bool IsEmpty(void) const 1291 { 1292 return primary == CECDEVICE_UNREGISTERED; 1293 } 1294 1295 /*! 1296 * @brief Calculate the ack-mask for this list, the mask to use when determining whether to send an ack message or not. 1297 * @return The ack-mask. 1298 */ AckMaskcec_logical_addresses1299 uint16_t AckMask(void) const 1300 { 1301 uint16_t mask = 0; 1302 for (unsigned int iPtr = 0; iPtr < 16; iPtr++) 1303 if (addresses[iPtr] == 1) 1304 mask |= 0x1 << iPtr; 1305 return mask; 1306 } 1307 1308 /*! 1309 * @brief Mark a logical address as 'set' 1310 * @param address The logical address to add to this list. 1311 */ Setcec_logical_addresses1312 void Set(cec_logical_address address) 1313 { 1314 if (primary == CECDEVICE_UNREGISTERED) 1315 primary = address; 1316 1317 addresses[(int) address] = 1; 1318 } 1319 1320 /*! 1321 * @brief Mark a logical address as 'unset' 1322 * @param address The logical address to remove from this list. 1323 */ Unsetcec_logical_addresses1324 void Unset(const cec_logical_address address) 1325 { 1326 if (primary == address) 1327 primary = CECDEVICE_UNREGISTERED; 1328 1329 addresses[(int) address] = 0; 1330 } 1331 1332 /*! 1333 * @brief Check whether an address is set in this list. 1334 * @param address The address to check. 1335 * @return True when set, false otherwise. 1336 */ IsSetcec_logical_addresses1337 bool IsSet(cec_logical_address address) const { return addresses[(int) address] == 1; } 1338 1339 /*! 1340 * @brief Check whether an address is set in this list. 1341 * @param pos The address to check. 1342 * @return True when set, false otherwise. 1343 */ 1344 bool operator[](uint8_t pos) const { return pos < 16 ? IsSet((cec_logical_address) pos) : false; } 1345 1346 bool operator==(const cec_logical_addresses &other) const 1347 { 1348 bool bEqual(true); 1349 for (uint8_t iPtr = 0; iPtr < 16; iPtr++) 1350 bEqual &= ((addresses[(int)iPtr] == 1) == other[iPtr]); 1351 return bEqual; 1352 } 1353 1354 bool operator!=(const cec_logical_addresses &other) const 1355 { 1356 return !(*this == other); 1357 } 1358 #endif 1359 } cec_logical_addresses; 1360 1361 typedef enum libcec_alert 1362 { 1363 CEC_ALERT_SERVICE_DEVICE, 1364 CEC_ALERT_CONNECTION_LOST, 1365 CEC_ALERT_PERMISSION_ERROR, 1366 CEC_ALERT_PORT_BUSY, 1367 CEC_ALERT_PHYSICAL_ADDRESS_ERROR, 1368 CEC_ALERT_TV_POLL_FAILED 1369 } libcec_alert; 1370 1371 typedef enum libcec_parameter_type 1372 { 1373 CEC_PARAMETER_TYPE_STRING, 1374 CEC_PARAMETER_TYPE_UNKOWN 1375 } libcec_parameter_type; 1376 1377 typedef struct libcec_parameter 1378 { 1379 libcec_parameter_type paramType; /**< the type of this parameter */ 1380 void* paramData; /**< the value of this parameter */ 1381 } libcec_parameter; 1382 1383 struct cec_adapter_stats 1384 { 1385 unsigned int tx_ack; 1386 unsigned int tx_nack; 1387 unsigned int tx_error; 1388 unsigned int rx_total; 1389 unsigned int rx_error; 1390 }; 1391 1392 typedef struct libcec_configuration libcec_configuration; 1393 1394 typedef struct ICECCallbacks 1395 { 1396 /*! 1397 * @brief Transfer a log message from libCEC to the client. 1398 * @param cbparam Callback parameter provided when the callbacks were set up 1399 * @param message The message to transfer. 1400 */ 1401 void (CEC_CDECL* logMessage)(void* cbparam, const cec_log_message* message); 1402 1403 /*! 1404 * @brief Transfer a keypress from libCEC to the client. 1405 * @param cbparam Callback parameter provided when the callbacks were set up 1406 * @param key The keypress to transfer. 1407 */ 1408 void (CEC_CDECL* keyPress)(void* cbparam, const cec_keypress* key); 1409 1410 /*! 1411 * @brief Transfer a CEC command from libCEC to the client. 1412 * @param cbparam Callback parameter provided when the callbacks were set up 1413 * @param command The command to transfer. 1414 */ 1415 void (CEC_CDECL* commandReceived)(void* cbparam, const cec_command* command); 1416 1417 /*! 1418 * @brief Transfer a changed configuration from libCEC to the client 1419 * @param cbparam Callback parameter provided when the callbacks were set up 1420 * @param configuration The configuration to transfer 1421 */ 1422 void (CEC_CDECL* configurationChanged)(void* cbparam, const libcec_configuration* configuration); 1423 1424 /*! 1425 * @brief Transfer a libcec alert message from libCEC to the client 1426 * @param cbparam Callback parameter provided when the callbacks were set up 1427 * @param alert The alert type transfer. 1428 * @param data Misc. additional information. 1429 */ 1430 void (CEC_CDECL* alert)(void* cbparam, const libcec_alert alert, const libcec_parameter param); 1431 1432 /*! 1433 * @brief Transfer a menu state change to the client. 1434 * Transfer a menu state change to the client. If the command returns 1, then the change will be processed by 1435 * the busdevice. If 0, then the state of the busdevice won't be changed, and will always be kept 'activated', 1436 * @warning CEC does not allow the player to suppress the menu state change on the TV, so the menu on the TV will always be displayed, whatever the return value of this method is. 1437 * so keypresses are always routed. 1438 * @param cbparam Callback parameter provided when the callbacks were set up 1439 * @param state The new value. 1440 * 1441 * @return 1 if libCEC should use this new value, 0 otherwise. 1442 */ 1443 int (CEC_CDECL* menuStateChanged)(void* cbparam, const cec_menu_state state); 1444 1445 /*! 1446 * @brief Called when a source that's handled by this client is activated. 1447 * @param cbparam Callback parameter provided when the callbacks were set up 1448 * @param logicalAddress The address that was just activated. 1449 * @param bActivated 1 if activated, 0 when deactivated. 1450 */ 1451 void (CEC_CDECL* sourceActivated)(void* cbParam, const cec_logical_address logicalAddress, const uint8_t bActivated); 1452 1453 #ifdef __cplusplus ICECCallbacksICECCallbacks1454 ICECCallbacks(void) { Clear(); } ~ICECCallbacksICECCallbacks1455 ~ICECCallbacks(void) { Clear(); }; 1456 ClearICECCallbacks1457 void Clear(void) 1458 { 1459 logMessage = nullptr; 1460 keyPress = nullptr; 1461 commandReceived = nullptr; 1462 configurationChanged = nullptr; 1463 alert = nullptr; 1464 menuStateChanged = nullptr; 1465 sourceActivated = nullptr; 1466 } 1467 #endif 1468 } ICECCallbacks; 1469 1470 #if CEC_LIB_VERSION_MAJOR >= 5 1471 #define LIBCEC_OSD_NAME_SIZE (15) 1472 #else 1473 #define LIBCEC_OSD_NAME_SIZE (13) 1474 #endif 1475 1476 struct libcec_configuration 1477 { 1478 uint32_t clientVersion; /*!< the version of the client that is connecting */ 1479 char strDeviceName[LIBCEC_OSD_NAME_SIZE]; /*!< the device name to use on the CEC bus, name + 0 terminator */ 1480 cec_device_type_list deviceTypes; /*!< the device type(s) to use on the CEC bus for libCEC */ 1481 uint8_t bAutodetectAddress; /*!< (read only) set to 1 by libCEC when the physical address was autodetected */ 1482 uint16_t iPhysicalAddress; /*!< the physical address of the CEC adapter */ 1483 cec_logical_address baseDevice; /*!< the logical address of the device to which the adapter is connected. only used when iPhysicalAddress = 0 or when the adapter doesn't support autodetection */ 1484 uint8_t iHDMIPort; /*!< the HDMI port to which the adapter is connected. only used when iPhysicalAddress = 0 or when the adapter doesn't support autodetection */ 1485 uint32_t tvVendor; /*!< override the vendor ID of the TV. leave this untouched to autodetect */ 1486 cec_logical_addresses wakeDevices; /*!< list of devices to wake when initialising libCEC or when calling PowerOnDevices() without any parameter. */ 1487 cec_logical_addresses powerOffDevices; /*!< list of devices to power off when calling StandbyDevices() without any parameter. */ 1488 1489 uint32_t serverVersion; /*!< the version number of the server. read-only */ 1490 1491 // player specific settings 1492 uint8_t bGetSettingsFromROM; /*!< true to get the settings from the ROM (if set, and a v2 ROM is present), false to use these settings. */ 1493 uint8_t bActivateSource; /*!< make libCEC the active source on the bus when starting the player application */ 1494 uint8_t bPowerOffOnStandby; /*!< put this PC in standby mode when the TV is switched off. only used when bShutdownOnStandby = 0 */ 1495 1496 void * callbackParam; /*!< the object to pass along with a call of the callback methods. NULL to ignore */ 1497 ICECCallbacks * callbacks; /*!< the callback methods to use. set this to NULL when not using callbacks */ 1498 1499 cec_logical_addresses logicalAddresses; /*!< (read-only) the current logical addresses. added in 1.5.3 */ 1500 uint16_t iFirmwareVersion; /*!< (read-only) the firmware version of the adapter. added in 1.6.0 */ 1501 char strDeviceLanguage[3]; /*!< the menu language used by the client. 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/ added in 1.6.2 */ 1502 uint32_t iFirmwareBuildDate; /*!< (read-only) the build date of the firmware, in seconds since epoch. if not available, this value will be set to 0. added in 1.6.2 */ 1503 uint8_t bMonitorOnly; /*!< won't allocate a CCECClient when starting the connection when set (same as monitor mode). added in 1.6.3 */ 1504 cec_version cecVersion; /*!< CEC spec version to use by libCEC. defaults to v1.4. added in 1.8.0 */ 1505 cec_adapter_type adapterType; /*!< type of the CEC adapter that we're connected to. added in 1.8.2 */ 1506 cec_user_control_code comboKey; /*!< key code that initiates combo keys. defaults to CEC_USER_CONTROL_CODE_STOP. CEC_USER_CONTROL_CODE_UNKNOWN to disable. added in 2.0.5 */ 1507 uint32_t iComboKeyTimeoutMs; /*!< timeout until the combo key is sent as normal keypress */ 1508 uint32_t iButtonRepeatRateMs; /*!< rate at which buttons autorepeat. 0 means rely on CEC device */ 1509 uint32_t iButtonReleaseDelayMs;/*!< duration after last update until a button is considered released */ 1510 uint32_t iDoubleTapTimeoutMs; /*!< prevent double taps within this timeout. defaults to 200ms. added in 4.0.0 */ 1511 uint8_t bAutoWakeAVR; /*!< set to 1 to automatically waking an AVR when the source is activated. added in 4.0.0 */ 1512 #if CEC_LIB_VERSION_MAJOR >= 5 1513 uint8_t bAutoPowerOn; /*!< set to 1 and save eeprom config to wake the tv when usb is powered. added in 5.0.0 / fw v9 */ 1514 #endif 1515 1516 #ifdef __cplusplus libcec_configurationlibcec_configuration1517 libcec_configuration(void) { Clear(); } ~libcec_configurationlibcec_configuration1518 ~libcec_configuration(void) { Clear(); } 1519 1520 bool operator==(const libcec_configuration &other) const 1521 { 1522 return ( clientVersion == other.clientVersion && 1523 !strcmp(strDeviceName, other.strDeviceName) && 1524 deviceTypes == other.deviceTypes && 1525 bAutodetectAddress == other.bAutodetectAddress && 1526 iPhysicalAddress == other.iPhysicalAddress && 1527 baseDevice == other.baseDevice && 1528 iHDMIPort == other.iHDMIPort && 1529 tvVendor == other.tvVendor && 1530 wakeDevices == other.wakeDevices && 1531 powerOffDevices == other.powerOffDevices && 1532 serverVersion == other.serverVersion && 1533 bGetSettingsFromROM == other.bGetSettingsFromROM && 1534 bActivateSource == other.bActivateSource && 1535 bPowerOffOnStandby == other.bPowerOffOnStandby && 1536 logicalAddresses == other.logicalAddresses && 1537 iFirmwareVersion == other.iFirmwareVersion && 1538 !strncmp(strDeviceLanguage, other.strDeviceLanguage, 3) && 1539 iFirmwareBuildDate == other.iFirmwareBuildDate && 1540 bMonitorOnly == other.bMonitorOnly && 1541 cecVersion == other.cecVersion && 1542 adapterType == other.adapterType && 1543 iDoubleTapTimeoutMs == other.iDoubleTapTimeoutMs && 1544 iButtonRepeatRateMs == other.iButtonRepeatRateMs && 1545 iButtonReleaseDelayMs == other.iButtonReleaseDelayMs && 1546 comboKey == other.comboKey && 1547 iComboKeyTimeoutMs == other.iComboKeyTimeoutMs && 1548 bAutoWakeAVR == other.bAutoWakeAVR 1549 #if CEC_LIB_VERSION_MAJOR >= 5 1550 && bAutoPowerOn == other.bAutoPowerOn 1551 #endif 1552 ); 1553 } 1554 1555 bool operator!=(const libcec_configuration &other) const 1556 { 1557 return !(*this == other); 1558 } 1559 1560 /*! 1561 * @brief Reset this configution struct to the default values. 1562 */ Clearlibcec_configuration1563 void Clear(void) 1564 { 1565 iPhysicalAddress = CEC_PHYSICAL_ADDRESS_TV; 1566 baseDevice = (cec_logical_address)CEC_DEFAULT_BASE_DEVICE; 1567 iHDMIPort = CEC_DEFAULT_HDMI_PORT; 1568 tvVendor = (uint32_t)CEC_VENDOR_UNKNOWN; 1569 clientVersion = LIBCEC_VERSION_CURRENT; 1570 serverVersion = LIBCEC_VERSION_CURRENT; 1571 bAutodetectAddress = 0; 1572 bGetSettingsFromROM = CEC_DEFAULT_SETTING_GET_SETTINGS_FROM_ROM; 1573 bActivateSource = CEC_DEFAULT_SETTING_ACTIVATE_SOURCE; 1574 bPowerOffOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY; 1575 iFirmwareVersion = CEC_FW_VERSION_UNKNOWN; 1576 memcpy(strDeviceLanguage, CEC_DEFAULT_DEVICE_LANGUAGE, 3); 1577 iFirmwareBuildDate = CEC_FW_BUILD_UNKNOWN; 1578 bMonitorOnly = 0; 1579 cecVersion = (cec_version)CEC_DEFAULT_SETTING_CEC_VERSION; 1580 adapterType = ADAPTERTYPE_UNKNOWN; 1581 iDoubleTapTimeoutMs = CEC_DOUBLE_TAP_TIMEOUT_MS; 1582 comboKey = CEC_USER_CONTROL_CODE_STOP; 1583 iComboKeyTimeoutMs = CEC_DEFAULT_COMBO_TIMEOUT_MS; 1584 iButtonRepeatRateMs = 0; 1585 iButtonReleaseDelayMs = CEC_BUTTON_TIMEOUT; 1586 bAutoWakeAVR = 0; 1587 #if CEC_LIB_VERSION_MAJOR >= 5 1588 bAutoPowerOn = 2; 1589 #endif 1590 1591 strDeviceName[0] = (char)0; 1592 deviceTypes.Clear(); 1593 logicalAddresses.Clear(); 1594 wakeDevices.Clear(); 1595 powerOffDevices.Clear(); 1596 1597 #if CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1 1598 powerOffDevices.Set(CECDEVICE_BROADCAST); 1599 #endif 1600 #if CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1 1601 wakeDevices.Set(CECDEVICE_TV); 1602 #endif 1603 1604 callbackParam = nullptr; 1605 callbacks = nullptr; 1606 } 1607 #endif 1608 }; 1609 1610 #ifdef __cplusplus 1611 }; 1612 }; 1613 #endif 1614 1615 #endif /* CECTYPES_H_ */ 1616