include/cectypes.h

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