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