cecclient.py

#! /usr/bin/env python3

# This file is part of the cecdaemon project
#
# Based on the demo of the python-libcec API, some original code left
# For more information about libCEC contact:
# Pulse-Eight Licensing	   <license@pulse-eight.com>
#	 http://www.pulse-eight.com/
#	 http://www.pulse-eight.net/
#
# copyright 2021 Alexandre Foley (alexandre.foley@usherbrooke.ca)
#
# Licensed under the GNU General Public License 
# See LICENSE file in the project root for full license information.

import cec
import inspect
import sys
import functools

# print(cec)


def multidispatch(*types):
	def register(function):
		name = function.__name__
		mm = multidispatch.registry.get(name)
		if mm is None:
			@functools.wraps(function)
			def wrapper(self, *args):
				types = tuple(arg.__class__ for arg in args) 
				function = wrapper.typemap.get(types)
				if function is None:
					raise TypeError("no match")
				return function(self, *args)
			wrapper.typemap = {}
			mm = multidispatch.registry[name] = wrapper
		if types in mm.typemap:
			raise TypeError("duplicate registration")
		mm.typemap[types] = function
		return mm
	return register
multidispatch.registry = {}

def register_mainloop_command(*cmds:str):
	"""Decorator to register a function for the interactive interface. """
	def deco(func):
		func.__cmds__ = cmds
		return func
	return deco


def Interactive_Mode( cls ):
	cls.help_string = "\n"
	for name, func in inspect.getmembers(cls):
		if hasattr(func, '__cmds__'):
			cmdstr = ', '.join(func.__cmds__)
			for cmd in func.__cmds__ :
				cls.interactive_cmd[cmd] = func
			cls.help_string = cls.help_string + '{:<15} {:>0}'.format(cmdstr, func.__doc__ )+ '\n'
	return cls

def str_to_logical_address(log_addr:str):
	try:
		out = int(log_addr)
		if not (out >= cec.CECDEVICE_TV and out <=cec.CECDEVICE_BROADCAST):
			out = cec.CECDEVICE_UNKNOWN
		return out
	except:
		print("logical adress must be a number in the range [{},{}]".format(cec.CECDEVICE_TV,cec.CECDEVICE_BROADCAST),file=self.stdout)

@Interactive_Mode
class pyCecClient:
	cecconfig = cec.libcec_configuration()
	lib = {}
	log_level = cec.CEC_LOG_ALL
	help_string = ""
	interactive_cmd = {}
	stdout = sys.stdout
	stdin = sys.stdin
	
	@register_mainloop_command("h","help")
	def PrintHelpMessage(self):
		"""Print this help message"""
		print(self.help_string,file=self.stdout)

	# create a new libcec_configuration
	def __init__(self,device_name = "pyLibCec",BeActiveSource=0,deviceType=cec.CEC_DEVICE_TYPE_RECORDING_DEVICE):
		self.cecconfig.strDeviceName = device_name
		self.cecconfig.bActivateSource = BeActiveSource
		self.cecconfig.deviceTypes.Add(deviceType)
		self.cecconfig.clientVersion = cec.LIBCEC_VERSION_CURRENT

	def SetLogCallback(self, callback):
		self.cecconfig.SetLogCallback(callback)

	def SetKeyPressCallback(self, callback):
		self.cecconfig.SetKeyPressCallback(callback)

	def SetCommandCallback(self, callback):
		self.cecconfig.SetCommandCallback(callback)

	def SetConfigurationChangedCallback(self, callback):
		self.cecconfig.SetConfigurationChangedCallback(callback)
	
	def SetSourceActivatedCallback(self,callback):
		self.cecconfig.SetSourceActivatedCallback(callback)
	
	def SetMenuStateCallback(self,callback):
		self.cecconfig.SetMenuStateCallback(callback)
	
	def SetAlertCallback(self,callback):
		self.cecconfig.SetAlertCallback(callback)

	def DetectAdapter(self):
		""" detect an adapter and return the com port path """
		retval = None
		adapters = self.lib.DetectAdapters()
		for adapter in adapters:
			print("found a CEC adapter:",file=self.stdout)
			print("port:	 " + adapter.strComName,file=self.stdout)
			print("vendor:   " + hex(adapter.iVendorId),file=self.stdout)
			print("product:  " + hex(adapter.iProductId),file=self.stdout)
			retval = adapter.strComName
		return retval

	# initialise libCEC
	def InitLibCec(self):
		self.lib:cec.ICECAdapter = cec.ICECAdapter.Create(self.cecconfig)
		# print libCEC version and compilation information
		print(
			"libCEC version "
			+ self.lib.VersionToString(self.cecconfig.serverVersion)
			+ " loaded: "
			+ self.lib.GetLibInfo()
		)

		# search for adapters
		self.adapter = self.DetectAdapter()
		if self.adapter == None:
			print("No adapters found",file=self.stdout)
		else:
			if self.lib.Open(self.adapter):
				print("connection opened",file=self.stdout)
			else:
				print("failed to open a connection to the CEC adapter",file=self.stdout)

	# display the addresses controlled by libCEC
	@register_mainloop_command('address')
	def ProcessCommandSelf(self):
		"""Display the address controled by libCEC"""
		addresses = self.lib.GetLogicalAddresses()
		strOut = "Addresses controlled by libCEC: "
		x = 0
		notFirst = False
		while x < 15:
			if addresses.IsSet(x):
				if notFirst:
					strOut += ", "
				strOut += self.lib.LogicalAddressToString(x)
				if self.lib.IsActiveSource(x):
					strOut += " (*)"
				notFirst = True
			x += 1
		print(strOut,file=self.stdout)

	# send an active source message
	@register_mainloop_command("be_as")
	def CommandActiveSource(self):
		"""make this CEC device the active source"""
		return self.lib.SetActiveSource()

	@register_mainloop_command("be_is")
	def CommandInactiveSource(self):
		"""Broadcast that this CEC device is no longer the source"""
		return self.lib.SetInactiveView()

	def GetActiveSource(self):
		"""return the logical address of the currently active source"""
		return self.lib.GetActiveSource()

	@register_mainloop_command("sleep_tv")
	def sleep_TV(self):
		"""
		Turn off the TV if this is the active source
		"""
		cur_as = self.GetActiveSource()
		if cur_as <=15 and cur_as >=0:
			if self.lib.GetLogicalAddresses()[cur_as]:
				self.StandbyDevice(0)
				self.CommandInactiveSource()

	def ToggleDevicePower(self,logical_address:int):
		"""toggle the power status of a device"""
		is_on = self.lib.GetDevicePowerStatus(logical_address)
		if is_on == cec.CEC_POWER_STATUS_STANDBY or is_on == cec.CEC_POWER_STATUS_UNKNOWN:
			out = self.PowerOnDevices(logical_address)
			self.CommandActiveSource()
			return out
		if is_on == cec.CEC_POWER_STATUS_ON:
			self.CommandInactiveSource()
			return self.StandbyDevice(logical_address)
		return False

	@register_mainloop_command("toggle_power")
	def ProcessToggleDevicePower(self,logical_address:str):
		"Toggle the power status of the device with the logical address"
		return self.ToggleDevicePower(str_to_logical_address(logical_address))

	@register_mainloop_command("get_as")
	def ProcessGetActiveSource(self):
		"""Obtain the logical address of the active source"""
		print(self.GetActiveSource(),file=self.stdout)

	def StandbyDevice(self,logical_address:int):
		"""
		put the device in standby
		"""
		return self.lib.StandbyDevices(logical_address)
	# send a standby command
	@register_mainloop_command("standby")
	def ProcessCommandStandby(self,logical_address:str):
		"""Send a standby command"""
		if not self.StandbyDevice(str_to_logical_address(logical_address)):
			print("invalid destination",file=self.stdout)

	def SetLogicalAddress(self,logical_address:int):
		"""set logical adress of the CEC device"""
		return self.lib.SetLogicalAddress(logical_address)

	@register_mainloop_command("set_la")
	def ProcessSetLogicalAddress(self,logical_address:str):
		"""set logical adress of the CEC device"""
		if not self.SetLogicalAddress(str_to_logical_address(logical_address)):
			print("command failed",file=self.stdout)

	def SetHDMIPort(self, base_device_logical_address:int, Port:int):
		return self.lib.SetHDMIPort(base_device_logical_address,Port)

	@register_mainloop_command("port")
	def ProcessSetHDMIPort(self, base_device_logical_address:str, Port:str):
		"change the HDMI port number of the CEC adapter."
		base_dev = str_to_logical_address(base_device_logical_address)
		if not self.lib.SetHDMIPort(base_dev,int(Port)):
			print("command failed",file=self.stdout)

	@multidispatch(str)
	def CommandTx(self,cmd:str):
		"""Send a command on the CEC line, string input"""
		return self.lib.Transmit(self.lib.CommandFromString(cmd))

	@multidispatch(int)
	def CommandTx(self,cmd:int):
		"""Send a command on the CEC line, integer input"""
		return self.lib.Transmit(cmd)

	# send a custom command
	@register_mainloop_command("tx","transmit")
	def ProcessCommandTx(self, data):
		"""Send a custom command"""
		cmd = self.lib.CommandFromString(data)
		print("transmit " + data,file=self.stdout)
		if self.lib.Transmit(cmd):
			print("command sent",file=self.stdout)
		else:
			print("failed to send command",file=self.stdout)

	# scan the bus and display devices that were found
	@register_mainloop_command("scan")
	def Scan(self):
		"""scan the bus and display devices that were found"""
		print("requesting CEC bus information ...",file=self.stdout)
		strLog = "CEC bus information\n===================\n"
		addresses = self.lib.GetActiveDevices()
#		activeSource = self.lib.GetActiveSource()
		x = 0
		while x < 15:
			if addresses.IsSet(x):
				vendorId = self.lib.GetDeviceVendorId(x)
				physicalAddress = self.lib.GetDevicePhysicalAddress(x)
				active = self.lib.IsActiveSource(x)
				cecVersion = self.lib.GetDeviceCecVersion(x)
				power = self.lib.GetDevicePowerStatus(x)
				osdName = self.lib.GetDeviceOSDName(x)
				strLog += (
					"device #"
					+ str(x)
					+ ": "
					+ self.lib.LogicalAddressToString(x)
					+ "\n"
				)
				strLog += "address:	   " + str(hex(physicalAddress)[2:]) + "\n"
				strLog += "active source: " + str(active) + "\n"
				strLog += "vendor:		" + self.lib.VendorIdToString(vendorId) + "\n"
				strLog += (
					"CEC version:   " + self.lib.CecVersionToString(cecVersion) + "\n"
				)
				strLog += "OSD name:	  " + osdName + "\n"
				strLog += (
					"power status:  " + self.lib.PowerStatusToString(power) + "\n\n\n"
				)
			x += 1
		print(strLog,file=self.stdout)

	@register_mainloop_command("volup")
	def VolumeUp(self):
		"""send a volume up command to the amp if present"""
		self.lib.VolumeUp()
	
	@register_mainloop_command("voldown")
	def VolumeDown(self):
		"""send a volume down command to the amp if present"""
		self.lib.VolumeDown()
	
	@register_mainloop_command("mute")
	def AudioToggleMute(self):
		"""send a mute/unmute command to the amp if present"""
		self.lib.AudioToggleMute()

	@register_mainloop_command("on")
	def PowerOnDevices(self, logical_address):
		"""power on the device with the given logical address"""
		logical_address = str_to_logical_address(logical_address)
		self.lib.PowerOnDevices(logical_address)

	
	def loop(self):
		if self.adapter:
			runLoop = True
			while runLoop:
				command = self.stdin.readline().strip().lower()
				if len(command)==0 or command.isspace():
					pass
				elif command == "q" or command == "quit":
					print("Exiting...",file=self.stdout)
					runLoop = False
				else:
					command = command.split()
					if command[0] in self.interactive_cmd:
						self.interactive_cmd[command[0]](self,*command[1:])
					else:
						print("unknown command.\n Type 'help' for a list of available commands",file=self.stdout)
		else:
			print("initialize the CEC client first!",file=self.stdout)


	# logging callback
	def LogCallback(self, level, time, message):
		if level & self.log_level == 0:
			return 0

		if level == cec.CEC_LOG_ERROR:
			levelstr = "ERROR:   "
		elif level == cec.CEC_LOG_WARNING:
			levelstr = "WARNING: "
		elif level == cec.CEC_LOG_NOTICE:
			levelstr = "NOTICE:  "
		elif level == cec.CEC_LOG_TRAFFIC:
			levelstr = "TRAFFIC: "
		elif level == cec.CEC_LOG_DEBUG:
			levelstr = "DEBUG:   "

		print(levelstr + "[" + str(time) + "]	 " + message,file = self.stdout)
		return 0

	# key press callback
	def KeyPressCallback(self, key, duration):
		print("[key pressed] " + str(key),file=self.stdout)
		return 0
	
	def switchback_badpa(self,cmd:str):
		"""
		This callback is very specific to this library author's setup.
		I have an hdmi switch between the soundbar and all my other devices, and that switch is dumb
		and confuse the hell out of everything that is connected through it.
		This callback watches for that confusion, and switch the signal route into an acceptable state (for my setup)
		"""
		print("[command received] " + cmd,file=self.stdout)
		# print("chopped command: ", cmd[4:])
		if cmd[4:] == "f:82:80:00":
			# print("switchback!",file=self.stdout)
			# self.bad_route = True
		# if cmd == ">> 5f:72:01":
			self.CommandTx("1f:82:11:00")
			# self.bad_route = False
		return 0


	# command received callback
	def CommandCallback(self, cmd:str):
		print("[command received] " + str(cmd),file=self.stdout)
		return 0


# logging callback
def log_callback(level, time, message):
	return lib.LogCallback(level, time, message)


# key press callback
def key_press_callback(key, duration):
	return lib.KeyPressCallback(key, duration)


# command callback
def command_callback(cmd):
	return lib.CommandCallback(cmd)


def switchback_badpa(cmd):
	lib.switchback_badpa(cmd)

def default_cecclient():
	lib = pyCecClient()
	lib.SetLogCallback(lib.LogCallback)
	lib.SetKeyPressCallback(lib.KeyPressCallback )
	lib.SetCommandCallback(lib.CommandCallback)
	return lib
	
def callback_print(*args):
	print("callback printer: ",file=self.stdout)
	for a in args:
		print(a,' ',file=self.stdout)

if __name__ == "__main__":
	# initialise libCEC
	lib = default_cecclient()
	# lib.log_level = 0
	# lib.SetCommandCallback(lib.switchback_badpa)
	# initialise libCEC and enter the main loop
	lib.InitLibCec()
	# lib.SetHDMIPort(5,1)
	lib.loop()

CEC_DEFAULT_PHYSICAL_ADDRESS = cec.CEC_DEFAULT_PHYSICAL_ADDRESS
CEC_DEFAULT_HDMI_PORT = cec.CEC_DEFAULT_HDMI_PORT
CEC_DEFAULT_BASE_DEVICE = cec.CEC_DEFAULT_BASE_DEVICE
CEC_BUTTON_TIMEOUT = cec.CEC_BUTTON_TIMEOUT
CEC_DOUBLE_TAP_TIMEOUT_MS = cec.CEC_DOUBLE_TAP_TIMEOUT_MS
CEC_POWER_STATE_REFRESH_TIME = cec.CEC_POWER_STATE_REFRESH_TIME
CEC_FW_VERSION_UNKNOWN = cec.CEC_FW_VERSION_UNKNOWN
CEC_FW_BUILD_UNKNOWN = cec.CEC_FW_BUILD_UNKNOWN
CEC_CONNECT_TRIES = cec.CEC_CONNECT_TRIES
CEC_PHYSICAL_ADDRESS_TV = cec.CEC_PHYSICAL_ADDRESS_TV
CEC_MIN_PHYSICAL_ADDRESS = cec.CEC_MIN_PHYSICAL_ADDRESS
CEC_MAX_PHYSICAL_ADDRESS = cec.CEC_MAX_PHYSICAL_ADDRESS
CEC_INVALID_PHYSICAL_ADDRESS = cec.CEC_INVALID_PHYSICAL_ADDRESS
CEC_MIN_VENDORID = cec.CEC_MIN_VENDORID
CEC_MAX_VENDORID = cec.CEC_MAX_VENDORID
CEC_INVALID_VENDORID = cec.CEC_INVALID_VENDORID
CEC_MIN_HDMI_PORTNUMBER = cec.CEC_MIN_HDMI_PORTNUMBER
CEC_MAX_HDMI_PORTNUMBER = cec.CEC_MAX_HDMI_PORTNUMBER
CEC_HDMI_PORTNUMBER_NONE = cec.CEC_HDMI_PORTNUMBER_NONE
CEC_DEFAULT_SETTING_ACTIVATE_SOURCE = cec.CEC_DEFAULT_SETTING_ACTIVATE_SOURCE
CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN = cec.CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN
CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY = cec.CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY
CEC_DEFAULT_DEVICE_LANGUAGE = cec.CEC_DEFAULT_DEVICE_LANGUAGE
CEC_DEFAULT_SETTING_AUTODETECT_ADDRESS = cec.CEC_DEFAULT_SETTING_AUTODETECT_ADDRESS
CEC_DEFAULT_SETTING_GET_SETTINGS_FROM_ROM = cec.CEC_DEFAULT_SETTING_GET_SETTINGS_FROM_ROM
CEC_DEFAULT_SETTING_CEC_VERSION = cec.CEC_DEFAULT_SETTING_CEC_VERSION
CEC_DEFAULT_TRANSMIT_RETRY_WAIT = cec.CEC_DEFAULT_TRANSMIT_RETRY_WAIT
CEC_DEFAULT_TRANSMIT_TIMEOUT = cec.CEC_DEFAULT_TRANSMIT_TIMEOUT
CEC_DEFAULT_TRANSMIT_WAIT = cec.CEC_DEFAULT_TRANSMIT_WAIT
CEC_DEFAULT_TRANSMIT_RETRIES = cec.CEC_DEFAULT_TRANSMIT_RETRIES
CEC_DEFAULT_CONNECT_TIMEOUT = cec.CEC_DEFAULT_CONNECT_TIMEOUT
CEC_DEFAULT_CONNECT_RETRY_WAIT = cec.CEC_DEFAULT_CONNECT_RETRY_WAIT
CEC_SERIAL_DEFAULT_BAUDRATE = cec.CEC_SERIAL_DEFAULT_BAUDRATE
CEC_CLEAR_INPUT_DEFAULT_WAIT = cec.CEC_CLEAR_INPUT_DEFAULT_WAIT
CEC_ACTIVE_SOURCE_SWITCH_RETRY_TIME_MS = cec.CEC_ACTIVE_SOURCE_SWITCH_RETRY_TIME_MS
CEC_FORWARD_STANDBY_MIN_INTERVAL = cec.CEC_FORWARD_STANDBY_MIN_INTERVAL
CEC_DEFAULT_COMBO_TIMEOUT_MS = cec.CEC_DEFAULT_COMBO_TIMEOUT_MS
CEC_RPI_VIRTUAL_PATH = cec.CEC_RPI_VIRTUAL_PATH
CEC_RPI_VIRTUAL_COM = cec.CEC_RPI_VIRTUAL_COM
CEC_TDA995x_PATH = cec.CEC_TDA995x_PATH
CEC_TDA995x_VIRTUAL_COM = cec.CEC_TDA995x_VIRTUAL_COM
CEC_EXYNOS_PATH = cec.CEC_EXYNOS_PATH
CEC_EXYNOS_VIRTUAL_COM = cec.CEC_EXYNOS_VIRTUAL_COM
CEC_MAX_DATA_PACKET_SIZE = cec.CEC_MAX_DATA_PACKET_SIZE
CEC_LINUX_PATH = cec.CEC_LINUX_PATH
CEC_LINUX_VIRTUAL_COM = cec.CEC_LINUX_VIRTUAL_COM
CEC_AOCEC_PATH = cec.CEC_AOCEC_PATH
CEC_AOCEC_VIRTUAL_COM = cec.CEC_AOCEC_VIRTUAL_COM
CEC_IMX_PATH = cec.CEC_IMX_PATH
CEC_IMX_VIRTUAL_COM = cec.CEC_IMX_VIRTUAL_COM
CEC_MIN_LIB_VERSION = cec.CEC_MIN_LIB_VERSION
MSGSTART = cec.MSGSTART
MSGEND = cec.MSGEND
MSGESC = cec.MSGESC
ESCOFFSET = cec.ESCOFFSET
DOUBLE_TAP_TIMEOUT_UNIT_SIZE = cec.DOUBLE_TAP_TIMEOUT_UNIT_SIZE
CEC_FEATURE_CONFIGURABLE_COMBO_KEY = cec.CEC_FEATURE_CONFIGURABLE_COMBO_KEY
CEC_ABORT_REASON_UNRECOGNIZED_OPCODE = cec.CEC_ABORT_REASON_UNRECOGNIZED_OPCODE
CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND = cec.CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND
CEC_ABORT_REASON_CANNOT_PROVIDE_SOURCE = cec.CEC_ABORT_REASON_CANNOT_PROVIDE_SOURCE
CEC_ABORT_REASON_INVALID_OPERAND = cec.CEC_ABORT_REASON_INVALID_OPERAND
CEC_ABORT_REASON_REFUSED = cec.CEC_ABORT_REASON_REFUSED
CEC_ANALOGUE_BROADCAST_TYPE_CABLE = cec.CEC_ANALOGUE_BROADCAST_TYPE_CABLE
CEC_ANALOGUE_BROADCAST_TYPE_SATELLITE = cec.CEC_ANALOGUE_BROADCAST_TYPE_SATELLITE
CEC_ANALOGUE_BROADCAST_TYPE_TERRESTIAL = cec.CEC_ANALOGUE_BROADCAST_TYPE_TERRESTIAL
CEC_AUDIO_RATE_RATE_CONTROL_OFF = cec.CEC_AUDIO_RATE_RATE_CONTROL_OFF
CEC_AUDIO_RATE_STANDARD_RATE_100 = cec.CEC_AUDIO_RATE_STANDARD_RATE_100
CEC_AUDIO_RATE_FAST_RATE_MAX_101 = cec.CEC_AUDIO_RATE_FAST_RATE_MAX_101
CEC_AUDIO_RATE_SLOW_RATE_MIN_99 = cec.CEC_AUDIO_RATE_SLOW_RATE_MIN_99
CEC_AUDIO_RATE_STANDARD_RATE_100_0 = cec.CEC_AUDIO_RATE_STANDARD_RATE_100_0
CEC_AUDIO_RATE_FAST_RATE_MAX_100_1 = cec.CEC_AUDIO_RATE_FAST_RATE_MAX_100_1
CEC_AUDIO_RATE_SLOW_RATE_MIN_99_9 = cec.CEC_AUDIO_RATE_SLOW_RATE_MIN_99_9
CEC_AUDIO_MUTE_STATUS_MASK = cec.CEC_AUDIO_MUTE_STATUS_MASK
CEC_AUDIO_VOLUME_STATUS_MASK = cec.CEC_AUDIO_VOLUME_STATUS_MASK
CEC_AUDIO_VOLUME_MIN = cec.CEC_AUDIO_VOLUME_MIN
CEC_AUDIO_VOLUME_MAX = cec.CEC_AUDIO_VOLUME_MAX
CEC_AUDIO_VOLUME_STATUS_UNKNOWN = cec.CEC_AUDIO_VOLUME_STATUS_UNKNOWN
CEC_FALSE = cec.CEC_FALSE
CEC_TRUE = cec.CEC_TRUE
CEC_VERSION_UNKNOWN = cec.CEC_VERSION_UNKNOWN
CEC_VERSION_1_2 = cec.CEC_VERSION_1_2
CEC_VERSION_1_2A = cec.CEC_VERSION_1_2A
CEC_VERSION_1_3 = cec.CEC_VERSION_1_3
CEC_VERSION_1_3A = cec.CEC_VERSION_1_3A
CEC_VERSION_1_4 = cec.CEC_VERSION_1_4
CEC_VERSION_2_0 = cec.CEC_VERSION_2_0
CEC_CHANNEL_NUMBER_FORMAT_MASK = cec.CEC_CHANNEL_NUMBER_FORMAT_MASK
CEC_1_PART_CHANNEL_NUMBER = cec.CEC_1_PART_CHANNEL_NUMBER
CEC_2_PART_CHANNEL_NUMBER = cec.CEC_2_PART_CHANNEL_NUMBER
CEC_MAJOR_CHANNEL_NUMBER_MASK = cec.CEC_MAJOR_CHANNEL_NUMBER_MASK
CEC_MINOR_CHANNEL_NUMBER_MASK = cec.CEC_MINOR_CHANNEL_NUMBER_MASK
CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND = cec.CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND
CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND = cec.CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND
CEC_DECK_CONTROL_MODE_STOP = cec.CEC_DECK_CONTROL_MODE_STOP
CEC_DECK_CONTROL_MODE_EJECT = cec.CEC_DECK_CONTROL_MODE_EJECT
CEC_DECK_INFO_PLAY = cec.CEC_DECK_INFO_PLAY
CEC_DECK_INFO_RECORD = cec.CEC_DECK_INFO_RECORD
CEC_DECK_INFO_PLAY_REVERSE = cec.CEC_DECK_INFO_PLAY_REVERSE
CEC_DECK_INFO_STILL = cec.CEC_DECK_INFO_STILL
CEC_DECK_INFO_SLOW = cec.CEC_DECK_INFO_SLOW
CEC_DECK_INFO_SLOW_REVERSE = cec.CEC_DECK_INFO_SLOW_REVERSE
CEC_DECK_INFO_FAST_FORWARD = cec.CEC_DECK_INFO_FAST_FORWARD
CEC_DECK_INFO_FAST_REVERSE = cec.CEC_DECK_INFO_FAST_REVERSE
CEC_DECK_INFO_NO_MEDIA = cec.CEC_DECK_INFO_NO_MEDIA
CEC_DECK_INFO_STOP = cec.CEC_DECK_INFO_STOP
CEC_DECK_INFO_SKIP_FORWARD_WIND = cec.CEC_DECK_INFO_SKIP_FORWARD_WIND
CEC_DECK_INFO_SKIP_REVERSE_REWIND = cec.CEC_DECK_INFO_SKIP_REVERSE_REWIND
CEC_DECK_INFO_INDEX_SEARCH_FORWARD = cec.CEC_DECK_INFO_INDEX_SEARCH_FORWARD
CEC_DECK_INFO_INDEX_SEARCH_REVERSE = cec.CEC_DECK_INFO_INDEX_SEARCH_REVERSE
CEC_DECK_INFO_OTHER_STATUS = cec.CEC_DECK_INFO_OTHER_STATUS
CEC_DECK_INFO_OTHER_STATUS_LG = cec.CEC_DECK_INFO_OTHER_STATUS_LG
CEC_DEVICE_TYPE_TV = cec.CEC_DEVICE_TYPE_TV
CEC_DEVICE_TYPE_RECORDING_DEVICE = cec.CEC_DEVICE_TYPE_RECORDING_DEVICE
CEC_DEVICE_TYPE_RESERVED = cec.CEC_DEVICE_TYPE_RESERVED
CEC_DEVICE_TYPE_TUNER = cec.CEC_DEVICE_TYPE_TUNER
CEC_DEVICE_TYPE_PLAYBACK_DEVICE = cec.CEC_DEVICE_TYPE_PLAYBACK_DEVICE
CEC_DEVICE_TYPE_AUDIO_SYSTEM = cec.CEC_DEVICE_TYPE_AUDIO_SYSTEM
CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME = cec.CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME
CEC_DISPLAY_CONTROL_DISPLAY_UNTIL_CLEARED = cec.CEC_DISPLAY_CONTROL_DISPLAY_UNTIL_CLEARED
CEC_DISPLAY_CONTROL_CLEAR_PREVIOUS_MESSAGE = cec.CEC_DISPLAY_CONTROL_CLEAR_PREVIOUS_MESSAGE
CEC_DISPLAY_CONTROL_RESERVED_FOR_FUTURE_USE = cec.CEC_DISPLAY_CONTROL_RESERVED_FOR_FUTURE_USE
CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PLUG = cec.CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PLUG
CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PHYSICAL_ADDRESS = cec.CEC_EXTERNAL_SOURCE_SPECIFIER_EXTERNAL_PHYSICAL_ADDRESS
CEC_MENU_REQUEST_TYPE_ACTIVATE = cec.CEC_MENU_REQUEST_TYPE_ACTIVATE
CEC_MENU_REQUEST_TYPE_DEACTIVATE = cec.CEC_MENU_REQUEST_TYPE_DEACTIVATE
CEC_MENU_REQUEST_TYPE_QUERY = cec.CEC_MENU_REQUEST_TYPE_QUERY
CEC_MENU_STATE_ACTIVATED = cec.CEC_MENU_STATE_ACTIVATED
CEC_MENU_STATE_DEACTIVATED = cec.CEC_MENU_STATE_DEACTIVATED
CEC_PLAY_MODE_PLAY_FORWARD = cec.CEC_PLAY_MODE_PLAY_FORWARD
CEC_PLAY_MODE_PLAY_REVERSE = cec.CEC_PLAY_MODE_PLAY_REVERSE
CEC_PLAY_MODE_PLAY_STILL = cec.CEC_PLAY_MODE_PLAY_STILL
CEC_PLAY_MODE_FAST_FORWARD_MIN_SPEED = cec.CEC_PLAY_MODE_FAST_FORWARD_MIN_SPEED
CEC_PLAY_MODE_FAST_FORWARD_MEDIUM_SPEED = cec.CEC_PLAY_MODE_FAST_FORWARD_MEDIUM_SPEED
CEC_PLAY_MODE_FAST_FORWARD_MAX_SPEED = cec.CEC_PLAY_MODE_FAST_FORWARD_MAX_SPEED
CEC_PLAY_MODE_FAST_REVERSE_MIN_SPEED = cec.CEC_PLAY_MODE_FAST_REVERSE_MIN_SPEED
CEC_PLAY_MODE_FAST_REVERSE_MEDIUM_SPEED = cec.CEC_PLAY_MODE_FAST_REVERSE_MEDIUM_SPEED
CEC_PLAY_MODE_FAST_REVERSE_MAX_SPEED = cec.CEC_PLAY_MODE_FAST_REVERSE_MAX_SPEED
CEC_PLAY_MODE_SLOW_FORWARD_MIN_SPEED = cec.CEC_PLAY_MODE_SLOW_FORWARD_MIN_SPEED
CEC_PLAY_MODE_SLOW_FORWARD_MEDIUM_SPEED = cec.CEC_PLAY_MODE_SLOW_FORWARD_MEDIUM_SPEED
CEC_PLAY_MODE_SLOW_FORWARD_MAX_SPEED = cec.CEC_PLAY_MODE_SLOW_FORWARD_MAX_SPEED
CEC_PLAY_MODE_SLOW_REVERSE_MIN_SPEED = cec.CEC_PLAY_MODE_SLOW_REVERSE_MIN_SPEED
CEC_PLAY_MODE_SLOW_REVERSE_MEDIUM_SPEED = cec.CEC_PLAY_MODE_SLOW_REVERSE_MEDIUM_SPEED
CEC_PLAY_MODE_SLOW_REVERSE_MAX_SPEED = cec.CEC_PLAY_MODE_SLOW_REVERSE_MAX_SPEED
CEC_POWER_STATUS_ON = cec.CEC_POWER_STATUS_ON
CEC_POWER_STATUS_STANDBY = cec.CEC_POWER_STATUS_STANDBY
CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON = cec.CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON
CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY = cec.CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY
CEC_POWER_STATUS_UNKNOWN = cec.CEC_POWER_STATUS_UNKNOWN
CEC_RECORD_SOURCE_TYPE_OWN_SOURCE = cec.CEC_RECORD_SOURCE_TYPE_OWN_SOURCE
CEC_RECORD_SOURCE_TYPE_DIGITAL_SERVICE = cec.CEC_RECORD_SOURCE_TYPE_DIGITAL_SERVICE
CEC_RECORD_SOURCE_TYPE_ANALOGUE_SERVICE = cec.CEC_RECORD_SOURCE_TYPE_ANALOGUE_SERVICE
CEC_RECORD_SOURCE_TYPE_EXTERNAL_PLUS = cec.CEC_RECORD_SOURCE_TYPE_EXTERNAL_PLUS
CEC_RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS = cec.CEC_RECORD_SOURCE_TYPE_EXTERNAL_PHYSICAL_ADDRESS
CEC_RECORD_STATUS_INFO_RECORDING_CURRENTLY_SELECTED_SOURCE = cec.CEC_RECORD_STATUS_INFO_RECORDING_CURRENTLY_SELECTED_SOURCE
CEC_RECORD_STATUS_INFO_RECORDING_DIGITAL_SERVICE = cec.CEC_RECORD_STATUS_INFO_RECORDING_DIGITAL_SERVICE
CEC_RECORD_STATUS_INFO_RECORDING_ANALOGUE_SERVICE = cec.CEC_RECORD_STATUS_INFO_RECORDING_ANALOGUE_SERVICE
CEC_RECORD_STATUS_INFO_RECORDING_EXTERNAL_INPUT = cec.CEC_RECORD_STATUS_INFO_RECORDING_EXTERNAL_INPUT
CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_DIGITAL_SERVICE = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_DIGITAL_SERVICE
CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_ANALOGUE_SERVICE = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_RECORD_ANALOGUE_SERVICE
CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_SELECT_REQUIRED_SERVICE = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_UNABLE_TO_SELECT_REQUIRED_SERVICE
CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_PLUG_NUMBER = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_PLUG_NUMBER
CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_ADDRESS = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_INVALID_EXTERNAL_ADDRESS
CEC_RECORD_STATUS_INFO_NO_RECORDING_CA_SYSTEM_NOT_SUPPORTED = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_CA_SYSTEM_NOT_SUPPORTED
CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_OR_INSUFFICIENT_ENTITLEMENTS = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_OR_INSUFFICIENT_ENTITLEMENTS
CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ALLOWED_TO_COPY_SOURCE = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ALLOWED_TO_COPY_SOURCE
CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_FURTHER_COPIES_ALLOWED = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_FURTHER_COPIES_ALLOWED
CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_MEDIA = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_MEDIA
CEC_RECORD_STATUS_INFO_NO_RECORDING_PLAYING = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_PLAYING
CEC_RECORD_STATUS_INFO_NO_RECORDING_ALREADY_RECORDING = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_ALREADY_RECORDING
CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROTECTED = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROTECTED
CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_SOURCE_SIGNAL = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NO_SOURCE_SIGNAL
CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROBLEM = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_MEDIA_PROBLEM
CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ENOUGH_SPACE_AVAILABLE = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_NOT_ENOUGH_SPACE_AVAILABLE
CEC_RECORD_STATUS_INFO_NO_RECORDING_PARENTAL_LOCK_ON = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_PARENTAL_LOCK_ON
CEC_RECORD_STATUS_INFO_RECORDING_TERMINATED_NORMALLY = cec.CEC_RECORD_STATUS_INFO_RECORDING_TERMINATED_NORMALLY
CEC_RECORD_STATUS_INFO_RECORDING_HAS_ALREADY_TERMINATED = cec.CEC_RECORD_STATUS_INFO_RECORDING_HAS_ALREADY_TERMINATED
CEC_RECORD_STATUS_INFO_NO_RECORDING_OTHER_REASON = cec.CEC_RECORD_STATUS_INFO_NO_RECORDING_OTHER_REASON
CEC_RECORDING_SEQUENCE_SUNDAY = cec.CEC_RECORDING_SEQUENCE_SUNDAY
CEC_RECORDING_SEQUENCE_MONDAY = cec.CEC_RECORDING_SEQUENCE_MONDAY
CEC_RECORDING_SEQUENCE_TUESDAY = cec.CEC_RECORDING_SEQUENCE_TUESDAY
CEC_RECORDING_SEQUENCE_WEDNESDAY = cec.CEC_RECORDING_SEQUENCE_WEDNESDAY
CEC_RECORDING_SEQUENCE_THURSDAY = cec.CEC_RECORDING_SEQUENCE_THURSDAY
CEC_RECORDING_SEQUENCE_FRIDAY = cec.CEC_RECORDING_SEQUENCE_FRIDAY
CEC_RECORDING_SEQUENCE_SATURDAY = cec.CEC_RECORDING_SEQUENCE_SATURDAY
CEC_RECORDING_SEQUENCE_ONCE_ONLY = cec.CEC_RECORDING_SEQUENCE_ONCE_ONLY
CEC_STATUS_REQUEST_ON = cec.CEC_STATUS_REQUEST_ON
CEC_STATUS_REQUEST_OFF = cec.CEC_STATUS_REQUEST_OFF
CEC_STATUS_REQUEST_ONCE = cec.CEC_STATUS_REQUEST_ONCE
CEC_SYSTEM_AUDIO_STATUS_OFF = cec.CEC_SYSTEM_AUDIO_STATUS_OFF
CEC_SYSTEM_AUDIO_STATUS_ON = cec.CEC_SYSTEM_AUDIO_STATUS_ON
CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_RECORDING = cec.CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_RECORDING
CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_MATCHING = cec.CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_MATCHING
CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_INF0_AVAILABLE = cec.CEC_TIMER_CLEARED_STATUS_DATA_TIMER_NOT_CLEARED_NO_INF0_AVAILABLE
CEC_TIMER_CLEARED_STATUS_DATA_TIMER_CLEARED = cec.CEC_TIMER_CLEARED_STATUS_DATA_TIMER_CLEARED
CEC_TIMER_OVERLAP_WARNING_NO_OVERLAP = cec.CEC_TIMER_OVERLAP_WARNING_NO_OVERLAP
CEC_TIMER_OVERLAP_WARNING_TIMER_BLOCKS_OVERLAP = cec.CEC_TIMER_OVERLAP_WARNING_TIMER_BLOCKS_OVERLAP
CEC_MEDIA_INFO_MEDIA_PRESENT_AND_NOT_PROTECTED = cec.CEC_MEDIA_INFO_MEDIA_PRESENT_AND_NOT_PROTECTED
CEC_MEDIA_INFO_MEDIA_PRESENT_BUT_PROTECTED = cec.CEC_MEDIA_INFO_MEDIA_PRESENT_BUT_PROTECTED
CEC_MEDIA_INFO_MEDIA_NOT_PRESENT = cec.CEC_MEDIA_INFO_MEDIA_NOT_PRESENT
CEC_MEDIA_INFO_FUTURE_USE = cec.CEC_MEDIA_INFO_FUTURE_USE
CEC_PROGRAMMED_INDICATOR_NOT_PROGRAMMED = cec.CEC_PROGRAMMED_INDICATOR_NOT_PROGRAMMED
CEC_PROGRAMMED_INDICATOR_PROGRAMMED = cec.CEC_PROGRAMMED_INDICATOR_PROGRAMMED
CEC_PROGRAMMED_INFO_FUTURE_USE = cec.CEC_PROGRAMMED_INFO_FUTURE_USE
CEC_PROGRAMMED_INFO_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING = cec.CEC_PROGRAMMED_INFO_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING
CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING = cec.CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPACE_AVAILABLE_FOR_RECORDING
CEC_PROGRAMMED_INFO_MAY_NOT_BE_ENOUGH_SPACE_AVAILABLE = cec.CEC_PROGRAMMED_INFO_MAY_NOT_BE_ENOUGH_SPACE_AVAILABLE
CEC_PROGRAMMED_INFO_NO_MEDIA_INFO_AVAILABLE = cec.CEC_PROGRAMMED_INFO_NO_MEDIA_INFO_AVAILABLE
CEC_NOT_PROGRAMMED_ERROR_INFO_FUTURE_USE = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_FUTURE_USE
CEC_NOT_PROGRAMMED_ERROR_INFO_NO_FREE_TIMER_AVAILABLE = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_NO_FREE_TIMER_AVAILABLE
CEC_NOT_PROGRAMMED_ERROR_INFO_DATE_OUT_OF_RANGE = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_DATE_OUT_OF_RANGE
CEC_NOT_PROGRAMMED_ERROR_INFO_RECORDING_SEQUENCE_ERROR = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_RECORDING_SEQUENCE_ERROR
CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PLUG_NUMBER = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PLUG_NUMBER
CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PHYSICAL_ADDRESS = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_INVALID_EXTERNAL_PHYSICAL_ADDRESS
CEC_NOT_PROGRAMMED_ERROR_INFO_CA_SYSTEM_NOT_SUPPORTED = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_CA_SYSTEM_NOT_SUPPORTED
CEC_NOT_PROGRAMMED_ERROR_INFO_NO_OR_INSUFFICIENT_CA_ENTITLEMENTS = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_NO_OR_INSUFFICIENT_CA_ENTITLEMENTS
CEC_NOT_PROGRAMMED_ERROR_INFO_DOES_NOT_SUPPORT_RESOLUTION = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_DOES_NOT_SUPPORT_RESOLUTION
CEC_NOT_PROGRAMMED_ERROR_INFO_PARENTAL_LOCK_ON = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_PARENTAL_LOCK_ON
CEC_NOT_PROGRAMMED_ERROR_INFO_CLOCK_FAILURE = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_CLOCK_FAILURE
CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_START = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_START
CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_END = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_RESERVED_FOR_FUTURE_USE_END
CEC_NOT_PROGRAMMED_ERROR_INFO_DUPLICATE_ALREADY_PROGRAMMED = cec.CEC_NOT_PROGRAMMED_ERROR_INFO_DUPLICATE_ALREADY_PROGRAMMED
CEC_RECORDING_FLAG_NOT_BEING_USED_FOR_RECORDING = cec.CEC_RECORDING_FLAG_NOT_BEING_USED_FOR_RECORDING
CEC_RECORDING_FLAG_BEING_USED_FOR_RECORDING = cec.CEC_RECORDING_FLAG_BEING_USED_FOR_RECORDING
CEC_TUNER_DISPLAY_INFO_DISPLAYING_DIGITAL_TUNER = cec.CEC_TUNER_DISPLAY_INFO_DISPLAYING_DIGITAL_TUNER
CEC_TUNER_DISPLAY_INFO_NOT_DISPLAYING_TUNER = cec.CEC_TUNER_DISPLAY_INFO_NOT_DISPLAYING_TUNER
CEC_TUNER_DISPLAY_INFO_DISPLAYING_ANALOGUE_TUNER = cec.CEC_TUNER_DISPLAY_INFO_DISPLAYING_ANALOGUE_TUNER
CEC_BROADCAST_SYSTEM_PAL_B_G = cec.CEC_BROADCAST_SYSTEM_PAL_B_G
CEC_BROADCAST_SYSTEM_SECAM_L1 = cec.CEC_BROADCAST_SYSTEM_SECAM_L1
CEC_BROADCAST_SYSTEM_PAL_M = cec.CEC_BROADCAST_SYSTEM_PAL_M
CEC_BROADCAST_SYSTEM_NTSC_M = cec.CEC_BROADCAST_SYSTEM_NTSC_M
CEC_BROADCAST_SYSTEM_PAL_I = cec.CEC_BROADCAST_SYSTEM_PAL_I
CEC_BROADCAST_SYSTEM_SECAM_DK = cec.CEC_BROADCAST_SYSTEM_SECAM_DK
CEC_BROADCAST_SYSTEM_SECAM_B_G = cec.CEC_BROADCAST_SYSTEM_SECAM_B_G
CEC_BROADCAST_SYSTEM_SECAM_L2 = cec.CEC_BROADCAST_SYSTEM_SECAM_L2
CEC_BROADCAST_SYSTEM_PAL_DK = cec.CEC_BROADCAST_SYSTEM_PAL_DK
CEC_BROADCAST_SYSTEM_OTHER_SYSTEM = cec.CEC_BROADCAST_SYSTEM_OTHER_SYSTEM
CEC_USER_CONTROL_CODE_SELECT = cec.CEC_USER_CONTROL_CODE_SELECT
CEC_USER_CONTROL_CODE_UP = cec.CEC_USER_CONTROL_CODE_UP
CEC_USER_CONTROL_CODE_DOWN = cec.CEC_USER_CONTROL_CODE_DOWN
CEC_USER_CONTROL_CODE_LEFT = cec.CEC_USER_CONTROL_CODE_LEFT
CEC_USER_CONTROL_CODE_RIGHT = cec.CEC_USER_CONTROL_CODE_RIGHT
CEC_USER_CONTROL_CODE_RIGHT_UP = cec.CEC_USER_CONTROL_CODE_RIGHT_UP
CEC_USER_CONTROL_CODE_RIGHT_DOWN = cec.CEC_USER_CONTROL_CODE_RIGHT_DOWN
CEC_USER_CONTROL_CODE_LEFT_UP = cec.CEC_USER_CONTROL_CODE_LEFT_UP
CEC_USER_CONTROL_CODE_LEFT_DOWN = cec.CEC_USER_CONTROL_CODE_LEFT_DOWN
CEC_USER_CONTROL_CODE_ROOT_MENU = cec.CEC_USER_CONTROL_CODE_ROOT_MENU
CEC_USER_CONTROL_CODE_SETUP_MENU = cec.CEC_USER_CONTROL_CODE_SETUP_MENU
CEC_USER_CONTROL_CODE_CONTENTS_MENU = cec.CEC_USER_CONTROL_CODE_CONTENTS_MENU
CEC_USER_CONTROL_CODE_FAVORITE_MENU = cec.CEC_USER_CONTROL_CODE_FAVORITE_MENU
CEC_USER_CONTROL_CODE_EXIT = cec.CEC_USER_CONTROL_CODE_EXIT
CEC_USER_CONTROL_CODE_TOP_MENU = cec.CEC_USER_CONTROL_CODE_TOP_MENU
CEC_USER_CONTROL_CODE_DVD_MENU = cec.CEC_USER_CONTROL_CODE_DVD_MENU
CEC_USER_CONTROL_CODE_NUMBER_ENTRY_MODE = cec.CEC_USER_CONTROL_CODE_NUMBER_ENTRY_MODE
CEC_USER_CONTROL_CODE_NUMBER11 = cec.CEC_USER_CONTROL_CODE_NUMBER11
CEC_USER_CONTROL_CODE_NUMBER12 = cec.CEC_USER_CONTROL_CODE_NUMBER12
CEC_USER_CONTROL_CODE_NUMBER0 = cec.CEC_USER_CONTROL_CODE_NUMBER0
CEC_USER_CONTROL_CODE_NUMBER1 = cec.CEC_USER_CONTROL_CODE_NUMBER1
CEC_USER_CONTROL_CODE_NUMBER2 = cec.CEC_USER_CONTROL_CODE_NUMBER2
CEC_USER_CONTROL_CODE_NUMBER3 = cec.CEC_USER_CONTROL_CODE_NUMBER3
CEC_USER_CONTROL_CODE_NUMBER4 = cec.CEC_USER_CONTROL_CODE_NUMBER4
CEC_USER_CONTROL_CODE_NUMBER5 = cec.CEC_USER_CONTROL_CODE_NUMBER5
CEC_USER_CONTROL_CODE_NUMBER6 = cec.CEC_USER_CONTROL_CODE_NUMBER6
CEC_USER_CONTROL_CODE_NUMBER7 = cec.CEC_USER_CONTROL_CODE_NUMBER7
CEC_USER_CONTROL_CODE_NUMBER8 = cec.CEC_USER_CONTROL_CODE_NUMBER8
CEC_USER_CONTROL_CODE_NUMBER9 = cec.CEC_USER_CONTROL_CODE_NUMBER9
CEC_USER_CONTROL_CODE_DOT = cec.CEC_USER_CONTROL_CODE_DOT
CEC_USER_CONTROL_CODE_ENTER = cec.CEC_USER_CONTROL_CODE_ENTER
CEC_USER_CONTROL_CODE_CLEAR = cec.CEC_USER_CONTROL_CODE_CLEAR
CEC_USER_CONTROL_CODE_NEXT_FAVORITE = cec.CEC_USER_CONTROL_CODE_NEXT_FAVORITE
CEC_USER_CONTROL_CODE_CHANNEL_UP = cec.CEC_USER_CONTROL_CODE_CHANNEL_UP
CEC_USER_CONTROL_CODE_CHANNEL_DOWN = cec.CEC_USER_CONTROL_CODE_CHANNEL_DOWN
CEC_USER_CONTROL_CODE_PREVIOUS_CHANNEL = cec.CEC_USER_CONTROL_CODE_PREVIOUS_CHANNEL
CEC_USER_CONTROL_CODE_SOUND_SELECT = cec.CEC_USER_CONTROL_CODE_SOUND_SELECT
CEC_USER_CONTROL_CODE_INPUT_SELECT = cec.CEC_USER_CONTROL_CODE_INPUT_SELECT
CEC_USER_CONTROL_CODE_DISPLAY_INFORMATION = cec.CEC_USER_CONTROL_CODE_DISPLAY_INFORMATION
CEC_USER_CONTROL_CODE_HELP = cec.CEC_USER_CONTROL_CODE_HELP
CEC_USER_CONTROL_CODE_PAGE_UP = cec.CEC_USER_CONTROL_CODE_PAGE_UP
CEC_USER_CONTROL_CODE_PAGE_DOWN = cec.CEC_USER_CONTROL_CODE_PAGE_DOWN
CEC_USER_CONTROL_CODE_POWER = cec.CEC_USER_CONTROL_CODE_POWER
CEC_USER_CONTROL_CODE_VOLUME_UP = cec.CEC_USER_CONTROL_CODE_VOLUME_UP
CEC_USER_CONTROL_CODE_VOLUME_DOWN = cec.CEC_USER_CONTROL_CODE_VOLUME_DOWN
CEC_USER_CONTROL_CODE_MUTE = cec.CEC_USER_CONTROL_CODE_MUTE
CEC_USER_CONTROL_CODE_PLAY = cec.CEC_USER_CONTROL_CODE_PLAY
CEC_USER_CONTROL_CODE_STOP = cec.CEC_USER_CONTROL_CODE_STOP
CEC_USER_CONTROL_CODE_PAUSE = cec.CEC_USER_CONTROL_CODE_PAUSE
CEC_USER_CONTROL_CODE_RECORD = cec.CEC_USER_CONTROL_CODE_RECORD
CEC_USER_CONTROL_CODE_REWIND = cec.CEC_USER_CONTROL_CODE_REWIND
CEC_USER_CONTROL_CODE_FAST_FORWARD = cec.CEC_USER_CONTROL_CODE_FAST_FORWARD
CEC_USER_CONTROL_CODE_EJECT = cec.CEC_USER_CONTROL_CODE_EJECT
CEC_USER_CONTROL_CODE_FORWARD = cec.CEC_USER_CONTROL_CODE_FORWARD
CEC_USER_CONTROL_CODE_BACKWARD = cec.CEC_USER_CONTROL_CODE_BACKWARD
CEC_USER_CONTROL_CODE_STOP_RECORD = cec.CEC_USER_CONTROL_CODE_STOP_RECORD
CEC_USER_CONTROL_CODE_PAUSE_RECORD = cec.CEC_USER_CONTROL_CODE_PAUSE_RECORD
CEC_USER_CONTROL_CODE_ANGLE = cec.CEC_USER_CONTROL_CODE_ANGLE
CEC_USER_CONTROL_CODE_SUB_PICTURE = cec.CEC_USER_CONTROL_CODE_SUB_PICTURE
CEC_USER_CONTROL_CODE_VIDEO_ON_DEMAND = cec.CEC_USER_CONTROL_CODE_VIDEO_ON_DEMAND
CEC_USER_CONTROL_CODE_ELECTRONIC_PROGRAM_GUIDE = cec.CEC_USER_CONTROL_CODE_ELECTRONIC_PROGRAM_GUIDE
CEC_USER_CONTROL_CODE_TIMER_PROGRAMMING = cec.CEC_USER_CONTROL_CODE_TIMER_PROGRAMMING
CEC_USER_CONTROL_CODE_INITIAL_CONFIGURATION = cec.CEC_USER_CONTROL_CODE_INITIAL_CONFIGURATION
CEC_USER_CONTROL_CODE_SELECT_BROADCAST_TYPE = cec.CEC_USER_CONTROL_CODE_SELECT_BROADCAST_TYPE
CEC_USER_CONTROL_CODE_SELECT_SOUND_PRESENTATION = cec.CEC_USER_CONTROL_CODE_SELECT_SOUND_PRESENTATION
CEC_USER_CONTROL_CODE_PLAY_FUNCTION = cec.CEC_USER_CONTROL_CODE_PLAY_FUNCTION
CEC_USER_CONTROL_CODE_PAUSE_PLAY_FUNCTION = cec.CEC_USER_CONTROL_CODE_PAUSE_PLAY_FUNCTION
CEC_USER_CONTROL_CODE_RECORD_FUNCTION = cec.CEC_USER_CONTROL_CODE_RECORD_FUNCTION
CEC_USER_CONTROL_CODE_PAUSE_RECORD_FUNCTION = cec.CEC_USER_CONTROL_CODE_PAUSE_RECORD_FUNCTION
CEC_USER_CONTROL_CODE_STOP_FUNCTION = cec.CEC_USER_CONTROL_CODE_STOP_FUNCTION
CEC_USER_CONTROL_CODE_MUTE_FUNCTION = cec.CEC_USER_CONTROL_CODE_MUTE_FUNCTION
CEC_USER_CONTROL_CODE_RESTORE_VOLUME_FUNCTION = cec.CEC_USER_CONTROL_CODE_RESTORE_VOLUME_FUNCTION
CEC_USER_CONTROL_CODE_TUNE_FUNCTION = cec.CEC_USER_CONTROL_CODE_TUNE_FUNCTION
CEC_USER_CONTROL_CODE_SELECT_MEDIA_FUNCTION = cec.CEC_USER_CONTROL_CODE_SELECT_MEDIA_FUNCTION
CEC_USER_CONTROL_CODE_SELECT_AV_INPUT_FUNCTION = cec.CEC_USER_CONTROL_CODE_SELECT_AV_INPUT_FUNCTION
CEC_USER_CONTROL_CODE_SELECT_AUDIO_INPUT_FUNCTION = cec.CEC_USER_CONTROL_CODE_SELECT_AUDIO_INPUT_FUNCTION
CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION = cec.CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION
CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION = cec.CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION
CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION = cec.CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION
CEC_USER_CONTROL_CODE_F1_BLUE = cec.CEC_USER_CONTROL_CODE_F1_BLUE
CEC_USER_CONTROL_CODE_F2_RED = cec.CEC_USER_CONTROL_CODE_F2_RED
CEC_USER_CONTROL_CODE_F3_GREEN = cec.CEC_USER_CONTROL_CODE_F3_GREEN
CEC_USER_CONTROL_CODE_F4_YELLOW = cec.CEC_USER_CONTROL_CODE_F4_YELLOW
CEC_USER_CONTROL_CODE_F5 = cec.CEC_USER_CONTROL_CODE_F5
CEC_USER_CONTROL_CODE_DATA = cec.CEC_USER_CONTROL_CODE_DATA
CEC_USER_CONTROL_CODE_AN_RETURN = cec.CEC_USER_CONTROL_CODE_AN_RETURN
CEC_USER_CONTROL_CODE_AN_CHANNELS_LIST = cec.CEC_USER_CONTROL_CODE_AN_CHANNELS_LIST
CEC_USER_CONTROL_CODE_MAX = cec.CEC_USER_CONTROL_CODE_MAX
CEC_USER_CONTROL_CODE_UNKNOWN = cec.CEC_USER_CONTROL_CODE_UNKNOWN
CECDEVICE_UNKNOWN = cec.CECDEVICE_UNKNOWN
CECDEVICE_TV = cec.CECDEVICE_TV
CECDEVICE_RECORDINGDEVICE1 = cec.CECDEVICE_RECORDINGDEVICE1
CECDEVICE_RECORDINGDEVICE2 = cec.CECDEVICE_RECORDINGDEVICE2
CECDEVICE_TUNER1 = cec.CECDEVICE_TUNER1
CECDEVICE_PLAYBACKDEVICE1 = cec.CECDEVICE_PLAYBACKDEVICE1
CECDEVICE_AUDIOSYSTEM = cec.CECDEVICE_AUDIOSYSTEM
CECDEVICE_TUNER2 = cec.CECDEVICE_TUNER2
CECDEVICE_TUNER3 = cec.CECDEVICE_TUNER3
CECDEVICE_PLAYBACKDEVICE2 = cec.CECDEVICE_PLAYBACKDEVICE2
CECDEVICE_RECORDINGDEVICE3 = cec.CECDEVICE_RECORDINGDEVICE3
CECDEVICE_TUNER4 = cec.CECDEVICE_TUNER4
CECDEVICE_PLAYBACKDEVICE3 = cec.CECDEVICE_PLAYBACKDEVICE3
CECDEVICE_RESERVED1 = cec.CECDEVICE_RESERVED1
CECDEVICE_RESERVED2 = cec.CECDEVICE_RESERVED2
CECDEVICE_FREEUSE = cec.CECDEVICE_FREEUSE
CECDEVICE_UNREGISTERED = cec.CECDEVICE_UNREGISTERED
CECDEVICE_BROADCAST = cec.CECDEVICE_BROADCAST
CEC_OPCODE_ACTIVE_SOURCE = cec.CEC_OPCODE_ACTIVE_SOURCE
CEC_OPCODE_IMAGE_VIEW_ON = cec.CEC_OPCODE_IMAGE_VIEW_ON
CEC_OPCODE_TEXT_VIEW_ON = cec.CEC_OPCODE_TEXT_VIEW_ON
CEC_OPCODE_INACTIVE_SOURCE = cec.CEC_OPCODE_INACTIVE_SOURCE
CEC_OPCODE_REQUEST_ACTIVE_SOURCE = cec.CEC_OPCODE_REQUEST_ACTIVE_SOURCE
CEC_OPCODE_ROUTING_CHANGE = cec.CEC_OPCODE_ROUTING_CHANGE
CEC_OPCODE_ROUTING_INFORMATION = cec.CEC_OPCODE_ROUTING_INFORMATION
CEC_OPCODE_SET_STREAM_PATH = cec.CEC_OPCODE_SET_STREAM_PATH
CEC_OPCODE_STANDBY = cec.CEC_OPCODE_STANDBY
CEC_OPCODE_RECORD_OFF = cec.CEC_OPCODE_RECORD_OFF
CEC_OPCODE_RECORD_ON = cec.CEC_OPCODE_RECORD_ON
CEC_OPCODE_RECORD_STATUS = cec.CEC_OPCODE_RECORD_STATUS
CEC_OPCODE_RECORD_TV_SCREEN = cec.CEC_OPCODE_RECORD_TV_SCREEN
CEC_OPCODE_CLEAR_ANALOGUE_TIMER = cec.CEC_OPCODE_CLEAR_ANALOGUE_TIMER
CEC_OPCODE_CLEAR_DIGITAL_TIMER = cec.CEC_OPCODE_CLEAR_DIGITAL_TIMER
CEC_OPCODE_CLEAR_EXTERNAL_TIMER = cec.CEC_OPCODE_CLEAR_EXTERNAL_TIMER
CEC_OPCODE_SET_ANALOGUE_TIMER = cec.CEC_OPCODE_SET_ANALOGUE_TIMER
CEC_OPCODE_SET_DIGITAL_TIMER = cec.CEC_OPCODE_SET_DIGITAL_TIMER
CEC_OPCODE_SET_EXTERNAL_TIMER = cec.CEC_OPCODE_SET_EXTERNAL_TIMER
CEC_OPCODE_SET_TIMER_PROGRAM_TITLE = cec.CEC_OPCODE_SET_TIMER_PROGRAM_TITLE
CEC_OPCODE_TIMER_CLEARED_STATUS = cec.CEC_OPCODE_TIMER_CLEARED_STATUS
CEC_OPCODE_TIMER_STATUS = cec.CEC_OPCODE_TIMER_STATUS
CEC_OPCODE_CEC_VERSION = cec.CEC_OPCODE_CEC_VERSION
CEC_OPCODE_GET_CEC_VERSION = cec.CEC_OPCODE_GET_CEC_VERSION
CEC_OPCODE_GIVE_PHYSICAL_ADDRESS = cec.CEC_OPCODE_GIVE_PHYSICAL_ADDRESS
CEC_OPCODE_GET_MENU_LANGUAGE = cec.CEC_OPCODE_GET_MENU_LANGUAGE
CEC_OPCODE_REPORT_PHYSICAL_ADDRESS = cec.CEC_OPCODE_REPORT_PHYSICAL_ADDRESS
CEC_OPCODE_SET_MENU_LANGUAGE = cec.CEC_OPCODE_SET_MENU_LANGUAGE
CEC_OPCODE_DECK_CONTROL = cec.CEC_OPCODE_DECK_CONTROL
CEC_OPCODE_DECK_STATUS = cec.CEC_OPCODE_DECK_STATUS
CEC_OPCODE_GIVE_DECK_STATUS = cec.CEC_OPCODE_GIVE_DECK_STATUS
CEC_OPCODE_PLAY = cec.CEC_OPCODE_PLAY
CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS = cec.CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS
CEC_OPCODE_SELECT_ANALOGUE_SERVICE = cec.CEC_OPCODE_SELECT_ANALOGUE_SERVICE
CEC_OPCODE_SELECT_DIGITAL_SERVICE = cec.CEC_OPCODE_SELECT_DIGITAL_SERVICE
CEC_OPCODE_TUNER_DEVICE_STATUS = cec.CEC_OPCODE_TUNER_DEVICE_STATUS
CEC_OPCODE_TUNER_STEP_DECREMENT = cec.CEC_OPCODE_TUNER_STEP_DECREMENT
CEC_OPCODE_TUNER_STEP_INCREMENT = cec.CEC_OPCODE_TUNER_STEP_INCREMENT
CEC_OPCODE_DEVICE_VENDOR_ID = cec.CEC_OPCODE_DEVICE_VENDOR_ID
CEC_OPCODE_GIVE_DEVICE_VENDOR_ID = cec.CEC_OPCODE_GIVE_DEVICE_VENDOR_ID
CEC_OPCODE_VENDOR_COMMAND = cec.CEC_OPCODE_VENDOR_COMMAND
CEC_OPCODE_VENDOR_COMMAND_WITH_ID = cec.CEC_OPCODE_VENDOR_COMMAND_WITH_ID
CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN = cec.CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN
CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP = cec.CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP
CEC_OPCODE_SET_OSD_STRING = cec.CEC_OPCODE_SET_OSD_STRING
CEC_OPCODE_GIVE_OSD_NAME = cec.CEC_OPCODE_GIVE_OSD_NAME
CEC_OPCODE_SET_OSD_NAME = cec.CEC_OPCODE_SET_OSD_NAME
CEC_OPCODE_MENU_REQUEST = cec.CEC_OPCODE_MENU_REQUEST
CEC_OPCODE_MENU_STATUS = cec.CEC_OPCODE_MENU_STATUS
CEC_OPCODE_USER_CONTROL_PRESSED = cec.CEC_OPCODE_USER_CONTROL_PRESSED
CEC_OPCODE_USER_CONTROL_RELEASE = cec.CEC_OPCODE_USER_CONTROL_RELEASE
CEC_OPCODE_GIVE_DEVICE_POWER_STATUS = cec.CEC_OPCODE_GIVE_DEVICE_POWER_STATUS
CEC_OPCODE_REPORT_POWER_STATUS = cec.CEC_OPCODE_REPORT_POWER_STATUS
CEC_OPCODE_FEATURE_ABORT = cec.CEC_OPCODE_FEATURE_ABORT
CEC_OPCODE_ABORT = cec.CEC_OPCODE_ABORT
CEC_OPCODE_GIVE_AUDIO_STATUS = cec.CEC_OPCODE_GIVE_AUDIO_STATUS
CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS = cec.CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS
CEC_OPCODE_REPORT_AUDIO_STATUS = cec.CEC_OPCODE_REPORT_AUDIO_STATUS
CEC_OPCODE_SET_SYSTEM_AUDIO_MODE = cec.CEC_OPCODE_SET_SYSTEM_AUDIO_MODE
CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST = cec.CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST
CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS = cec.CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS
CEC_OPCODE_SET_AUDIO_RATE = cec.CEC_OPCODE_SET_AUDIO_RATE
CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTORS = cec.CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTORS
CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTORS = cec.CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTORS
CEC_OPCODE_START_ARC = cec.CEC_OPCODE_START_ARC
CEC_OPCODE_REPORT_ARC_STARTED = cec.CEC_OPCODE_REPORT_ARC_STARTED
CEC_OPCODE_REPORT_ARC_ENDED = cec.CEC_OPCODE_REPORT_ARC_ENDED
CEC_OPCODE_REQUEST_ARC_START = cec.CEC_OPCODE_REQUEST_ARC_START
CEC_OPCODE_REQUEST_ARC_END = cec.CEC_OPCODE_REQUEST_ARC_END
CEC_OPCODE_END_ARC = cec.CEC_OPCODE_END_ARC
CEC_OPCODE_CDC = cec.CEC_OPCODE_CDC
CEC_OPCODE_NONE = cec.CEC_OPCODE_NONE
CEC_LOG_ERROR = cec.CEC_LOG_ERROR
CEC_LOG_WARNING = cec.CEC_LOG_WARNING
CEC_LOG_NOTICE = cec.CEC_LOG_NOTICE
CEC_LOG_TRAFFIC = cec.CEC_LOG_TRAFFIC
CEC_LOG_DEBUG = cec.CEC_LOG_DEBUG
CEC_LOG_ALL = cec.CEC_LOG_ALL
CEC_DEVICE_STATUS_UNKNOWN = cec.CEC_DEVICE_STATUS_UNKNOWN
CEC_DEVICE_STATUS_PRESENT = cec.CEC_DEVICE_STATUS_PRESENT
CEC_DEVICE_STATUS_NOT_PRESENT = cec.CEC_DEVICE_STATUS_NOT_PRESENT
CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC = cec.CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC
CEC_VENDOR_TOSHIBA = cec.CEC_VENDOR_TOSHIBA
CEC_VENDOR_SAMSUNG = cec.CEC_VENDOR_SAMSUNG
CEC_VENDOR_DENON = cec.CEC_VENDOR_DENON
CEC_VENDOR_MARANTZ = cec.CEC_VENDOR_MARANTZ
CEC_VENDOR_LOEWE = cec.CEC_VENDOR_LOEWE
CEC_VENDOR_ONKYO = cec.CEC_VENDOR_ONKYO
CEC_VENDOR_MEDION = cec.CEC_VENDOR_MEDION
CEC_VENDOR_TOSHIBA2 = cec.CEC_VENDOR_TOSHIBA2
CEC_VENDOR_APPLE = cec.CEC_VENDOR_APPLE
CEC_VENDOR_PULSE_EIGHT = cec.CEC_VENDOR_PULSE_EIGHT
CEC_VENDOR_HARMAN_KARDON2 = cec.CEC_VENDOR_HARMAN_KARDON2
CEC_VENDOR_GOOGLE = cec.CEC_VENDOR_GOOGLE
CEC_VENDOR_AKAI = cec.CEC_VENDOR_AKAI
CEC_VENDOR_AOC = cec.CEC_VENDOR_AOC
CEC_VENDOR_PANASONIC = cec.CEC_VENDOR_PANASONIC
CEC_VENDOR_PHILIPS = cec.CEC_VENDOR_PHILIPS
CEC_VENDOR_DAEWOO = cec.CEC_VENDOR_DAEWOO
CEC_VENDOR_YAMAHA = cec.CEC_VENDOR_YAMAHA
CEC_VENDOR_GRUNDIG = cec.CEC_VENDOR_GRUNDIG
CEC_VENDOR_PIONEER = cec.CEC_VENDOR_PIONEER
CEC_VENDOR_LG = cec.CEC_VENDOR_LG
CEC_VENDOR_SHARP = cec.CEC_VENDOR_SHARP
CEC_VENDOR_SONY = cec.CEC_VENDOR_SONY
CEC_VENDOR_BROADCOM = cec.CEC_VENDOR_BROADCOM
CEC_VENDOR_SHARP2 = cec.CEC_VENDOR_SHARP2
CEC_VENDOR_VIZIO = cec.CEC_VENDOR_VIZIO
CEC_VENDOR_BENQ = cec.CEC_VENDOR_BENQ
CEC_VENDOR_HARMAN_KARDON = cec.CEC_VENDOR_HARMAN_KARDON
CEC_VENDOR_UNKNOWN = cec.CEC_VENDOR_UNKNOWN
ADAPTERTYPE_UNKNOWN = cec.ADAPTERTYPE_UNKNOWN
ADAPTERTYPE_P8_EXTERNAL = cec.ADAPTERTYPE_P8_EXTERNAL
ADAPTERTYPE_P8_DAUGHTERBOARD = cec.ADAPTERTYPE_P8_DAUGHTERBOARD
ADAPTERTYPE_RPI = cec.ADAPTERTYPE_RPI
ADAPTERTYPE_TDA995x = cec.ADAPTERTYPE_TDA995x
ADAPTERTYPE_EXYNOS = cec.ADAPTERTYPE_EXYNOS
ADAPTERTYPE_LINUX = cec.ADAPTERTYPE_LINUX
ADAPTERTYPE_AOCEC = cec.ADAPTERTYPE_AOCEC
ADAPTERTYPE_IMX = cec.ADAPTERTYPE_IMX
LIBCEC_VERSION_CURRENT = cec.LIBCEC_VERSION_CURRENT

CEC_ALERT_SERVICE_DEVICE = cec.CEC_ALERT_SERVICE_DEVICE
CEC_ALERT_CONNECTION_LOST = cec.CEC_ALERT_CONNECTION_LOST
CEC_ALERT_PERMISSION_ERROR = cec.CEC_ALERT_PERMISSION_ERROR
CEC_ALERT_PORT_BUSY = cec.CEC_ALERT_PORT_BUSY
CEC_ALERT_PHYSICAL_ADDRESS_ERROR = cec.CEC_ALERT_PHYSICAL_ADDRESS_ERROR
CEC_ALERT_TV_POLL_FAILED = cec.CEC_ALERT_TV_POLL_FAILED
CEC_PARAMETER_TYPE_STRING = cec.CEC_PARAMETER_TYPE_STRING
CEC_PARAMETER_TYPE_UNKOWN = cec.CEC_PARAMETER_TYPE_UNKOWN
	