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