include/cectypes.h

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