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