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