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