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