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