int a, b, c, d;

if( sscanf(addr, "%x.%x.%x.%x", &a, &b, &c, &d) == 4 ) {

if( a > 0xF || b > 0xF || c > 0xF || d > 0xF ) return -1;

if( a < 0 || b < 0 || c < 0 || d < 0 ) return -1;

return (a << 12) | (b << 8) | (c << 4) | d;

} else {

return -1;

}

assert(parse_physical_addr("0.0.0.0") == 0);

assert(parse_physical_addr("F.0.0.0") == 0xF000);

assert(parse_physical_addr("0.F.0.0") == 0x0F00);

assert(parse_physical_addr("0.0.F.0") == 0x00F0);

assert(parse_physical_addr("0.0.0.F") == 0x000F);

assert(parse_physical_addr("-1.0.0.0") == -1);

assert(parse_physical_addr("0.-1.0.0") == -1);

assert(parse_physical_addr("0.0.-1.0") == -1);

assert(parse_physical_addr("0.0.0.-1") == -1);

assert(parse_physical_addr("foo") == -1);

assert(parse_physical_addr("F.F.F.F") == 0xFFFF);

assert(parse_physical_addr("f.f.f.f") == 0xFFFF);

std::list<CEC_ADAPTER_TYPE> res;

// release the Global Interpreter lock

Py_BEGIN_ALLOW_THREADS

// get adapters

int cec_count = 10;

CEC_ADAPTER_TYPE * dev_list = (CEC_ADAPTER_TYPE*)malloc(

cec_count * sizeof(CEC_ADAPTER_TYPE));

int count = CEC_adapter->CEC_FIND_ADAPTERS(dev_list, cec_count);

if( count > cec_count ) {

cec_count = count;

dev_list = (CEC_ADAPTER_TYPE*)realloc(dev_list,

cec_count * sizeof(CEC_ADAPTER_TYPE));

count = CEC_adapter->CEC_FIND_ADAPTERS(dev_list, cec_count);

count = (std::min)(count, cec_count);

}

for( int i=0; i<count; i++ ) {

res.push_back(dev_list[i]);

}

free(dev_list);

// acquire the GIL before returning to code that uses python objects

Py_END_ALLOW_THREADS

return res;

public:

long int event;

PyObject * cb;

Callback(long int e, PyObject * c) : event(e), cb(c) {

}

#endif

debug("got log callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#if CEC_LIB_VERSION_MAJOR >= 4

int level = message->level;

long int time = message->time;

const char* msg = message->message;

#else

int level = message.level;

long int time = message.time;

const char* msg = message.message;

#endif

// decode message ignoring invalid characters

PyObject * umsg = PyUnicode_DecodeASCII(msg, strlen(msg), "ignore");

PyObject * args = Py_BuildValue("(iilO)", EVENT_LOG,

level,

time,

umsg);

if( args ) {

trigger_event(EVENT_LOG, args);

Py_DECREF(args);

}

Py_XDECREF(umsg);

PyGILState_Release(gstate);

#if CEC_LIB_VERSION_MAJOR >= 4

return;

#else

return 1;

#endif

#endif

debug("got keypress callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#if CEC_LIB_VERSION_MAJOR >= 4

cec_user_control_code keycode = key->keycode;

unsigned int duration = key->duration;

#else

cec_user_control_code keycode = key.keycode;

unsigned int duration = key.duration;

#endif

PyObject * args = Py_BuildValue("(iBI)", EVENT_KEYPRESS,

keycode,

duration);

if( args ) {

trigger_event(EVENT_KEYPRESS, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

#if CEC_LIB_VERSION_MAJOR >= 4

return;

#else

return 1;

#endif

#endif

debug("got command callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#if CEC_LIB_VERSION_MAJOR >= 4

const cec_command * cmd = command;

#else

const cec_command * cmd = &command;

#endif

PyObject * args = Py_BuildValue("(iO&)", EVENT_COMMAND, convert_cmd, cmd);

if( args ) {

trigger_event(EVENT_COMMAND, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

#if CEC_LIB_VERSION_MAJOR >= 4

return;

#else

return 1;

#endif

#endif

debug("got config callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

// TODO: figure out how to pass these as parameters

// yeah... right.

// we'll probably have to come up with some functions for converting the

// libcec_configuration class into a python Object

// this will probably be _lots_ of work and should probably wait until

// a later release, or when it becomes necessary.

PyObject * args = Py_BuildValue("(i)", EVENT_CONFIG_CHANGE);

if( args ) {

// don't bother triggering an event until we can actually pass arguments

//trigger_event(EVENT_CONFIG_CHANGE, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

#if CEC_LIB_VERSION_MAJOR >= 4

return;

#else

return 1;

#endif

#endif

debug("got alert callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

PyObject * param = Py_None;

if( p.paramType == CEC_PARAMETER_TYPE_STRING ) {

param = Py_BuildValue("s", p.paramData);

} else {

Py_INCREF(param);

}

PyObject * args = Py_BuildValue("(iiN)", EVENT_ALERT, alert, param);

if( args ) {

trigger_event(EVENT_ALERT, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

#if CEC_LIB_VERSION_MAJOR >= 4

return;

#else

return 1;

#endif

debug("got menu callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

PyObject * args = Py_BuildValue("(ii)", EVENT_MENU_CHANGED, menu);

if( args ) {

trigger_event(EVENT_MENU_CHANGED, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

return 1;

const uint8_t state) {

debug("got activated callback\n");

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

PyObject * active = (state == 1) ? Py_True : Py_False;

PyObject * args = Py_BuildValue("(iOi)", EVENT_ACTIVATED, active,

logical_address);

if( args ) {

trigger_event(EVENT_ACTIVATED, args);

Py_DECREF(args);

}

PyGILState_Release(gstate);

return;

#endif

// Make sure threads are enabled in the python interpreter

// this also acquires the global interpreter lock

PyEval_InitThreads();

// set up libcec

// libcec config

CEC_config = new libcec_configuration();

CEC_config->Clear();

snprintf(CEC_config->strDeviceName, 13, "python-cec");

// CEC_CLIENT_VERSION_CURRENT was introduced in 2.0.4

// just use 2.1.0 because the conditional is simpler

#if CEC_LIB_VERSION_MAJOR >= 3

CEC_config->clientVersion = LIBCEC_VERSION_CURRENT;

#elif CEC_LIB_VERSION_MAJOR >= 2 && CEC_LIB_VERSION_MINOR >= 1

CEC_config->clientVersion = CEC_CLIENT_VERSION_CURRENT;

#else

// fall back to 1.6.0 since it's the lowest common denominator shipped with

// Ubuntu

CEC_config->clientVersion = CEC_CLIENT_VERSION_1_6_0;

#endif

CEC_config->bActivateSource = 0;

CEC_config->deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);

// libcec callbacks

CEC_callbacks = new ICECCallbacks();

#if CEC_LIB_VERSION_MAJOR > 1 || ( CEC_LIB_VERSION_MAJOR == 1 && CEC_LIB_VERSION_MINOR >= 7 )

CEC_callbacks->Clear();

#endif

#if CEC_LIB_VERSION_MAJOR >= 4

CEC_callbacks->logMessage = log_cb;

CEC_callbacks->keyPress = keypress_cb;

CEC_callbacks->commandReceived = command_cb;

CEC_callbacks->configurationChanged = config_cb;

CEC_callbacks->alert = alert_cb;

CEC_callbacks->menuStateChanged = menu_cb;

CEC_callbacks->sourceActivated = activated_cb;

#else

CEC_callbacks->CBCecLogMessage = log_cb;

CEC_callbacks->CBCecKeyPress = keypress_cb;

CEC_callbacks->CBCecCommand = command_cb;

CEC_callbacks->CBCecConfigurationChanged = config_cb;

CEC_callbacks->CBCecAlert = alert_cb;

CEC_callbacks->CBCecMenuStateChanged = menu_cb;

CEC_callbacks->CBCecSourceActivated = activated_cb;

#endif

CEC_config->callbacks = CEC_callbacks;

CEC_adapter = (ICECAdapter*)CECInitialise(CEC_config);

if( !CEC_adapter ) {

PyErr_SetString(PyExc_IOError, "Failed to initialize libcec");

INITERROR;

}

#if CEC_LIB_VERSION_MAJOR > 1 || ( CEC_LIB_VERSION_MAJOR == 1 && CEC_LIB_VERSION_MINOR >= 8 )

CEC_adapter->InitVideoStandalone();

#endif

// set up python module

PyTypeObject * dev = DeviceTypeInit(CEC_adapter);

Device = (PyObject*)dev;

if(PyType_Ready(dev) < 0 ) INITERROR;

#if PY_MAJOR_VERSION >= 3

PyObject * m = PyModule_Create(&moduledef);

#else

PyObject * m = Py_InitModule("cec", CecMethods);

#endif

if( m == NULL ) INITERROR;

Py_INCREF(dev);

PyModule_AddObject(m, "Device", (PyObject*)dev);

// constants for event types

PyModule_AddIntMacro(m, EVENT_LOG);

PyModule_AddIntMacro(m, EVENT_KEYPRESS);

PyModule_AddIntMacro(m, EVENT_COMMAND);

PyModule_AddIntMacro(m, EVENT_CONFIG_CHANGE);

PyModule_AddIntMacro(m, EVENT_ALERT);