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