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