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