include/cectypes.h

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