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