int ltr_int_tracker_init(struct camera_control_block *ccb)
{
ltr_int_log_message("Initializing the tracker.\n");
assert(ccb != NULL);
assert((ccb->device.category == tir) || (ccb->device.category == tir_open));
last_threshold = -1;
char *libname = NULL;
dbg_flag_type fakeusb_dbg_flag = ltr_int_get_dbg_flag('f');
if(fakeusb_dbg_flag == DBG_ON) {
libname = "libfakeusb";
} else {
libname = "libltusb1";
}
if((libhandle = ltr_int_load_library(libname, functions)) == NULL) {
ltr_int_log_message("Problem loading library %s!\n", libname);
return -1;
}
if(!ltr_int_tir_init_prefs()) {
ltr_int_log_message("Problem initializing TrackIr prefs!\n");
return -1;
}
ltr_int_log_message("Lib loaded, prefs read...\n");
if(ltr_int_open_tir(false, !ltr_int_is_model_active())) {
tir_info info;
ltr_int_get_tir_info(&info);
ccb->pixel_width = info.width;
ccb->pixel_height = info.height;
ltr_int_prepare_for_processing(ccb->pixel_width, ccb->pixel_height);
return 0;
} else {
return -1;
}
}
int ltr_int_tracker_init(struct camera_control_block *ccb)
{
if(!ltr_int_joy_init_prefs()){
ltr_int_log_message("Can't initialize joystick preferences.\n");
return -1;
}
const char *devName = ccb->device.device_id;
fd = findJoystick(ifc, devName);
if(fd < 0){
ltr_int_log_message("Device '%s' not found.\n", devName);
return -1;
}
//Js has all the axes normalized to +-32767, but evdev reports
// them in their native resolutions; enumerating them allows me
// to normalize them to +-32767 too...
if(ifc == e_EVDEV){
if(!enumerateAxes(e_EVDEV, fd, &axes)){
ltr_int_log_message("Couldn't enumerate axes.\n");
return -1;
}
}
yaw = pitch = roll = tx = ty = tz = 0.0f;
cntr = 0;
bm = 0;
return 0;
}
bool ltr_int_receive_data(int in_ep, unsigned char data[], size_t size, size_t *transferred,
long timeout)
{
if(timeout == 0){
timeout = 500;
}
*transferred = 0;
int res;
//ltr_int_log_message("Reading bulk data.\n");
if((res = libusb_bulk_transfer(handle, in_ep, data, size, (int*)transferred, timeout))){
if(res != LIBUSB_ERROR_TIMEOUT){
ltr_int_log_message("Problem reading data from TIR@ep %d! %d - %d transferred\n",
in_ep, res, *transferred);
return false;
}else{
ltr_int_log_message("Data receive request timed out!\n");
}
}else{
if(comm_dbg_flag == DBG_ON){
ltr_int_log_packet("in", data, *transferred);
}
}
//ltr_int_log_message("Bulk data received.\n");
return true;
}
static bool start_master()
{
bool is_child;
//master inherits fds!
ltr_int_log_message("Start master\n");
int socket = ltr_int_connect_to_socket(ltr_int_master_socket_name());
ltr_int_log_message("socket %d\n", socket);
if(socket < 0){
//no master there yet, so lets start one
ltr_int_log_message("Master is not running, start it\n");
if(!getenv("LTR_KEEP_LD_LIBRARY_PATH")){
ltr_int_log_message("Reseting LD_LIBRARY_PATH.\n");
unsetenv("LD_LIBRARY_PATH");
}else{
ltr_int_log_message("LTR_KEEP_LD_LIBRARY_PATH set, keeping LD_LIBRARY_PATH set.\n");
}
char *args[] = {"srv", NULL};
args[0] = ltr_int_get_app_path("/ltr_server1");
ltr_int_fork_child(args, &is_child);
int status;
//Disable the wait when not daemonizing master!!!
wait(&status);
//At this point master is either running or exited (depending on the state of socket)
free(args[0]);
}
close(socket);
//At this point either master runs already, or we just started one
return true;
}
int main(int argc, char *argv[])
{
ltr_int_check_root();
if(!checkCmdLine(argc, argv)){
ltr_int_log_message("Wrong arguments!\n");
return EXIT_FAILURE;
}
if(doEnumCams()){
enumerateCameras();
}else if(doCapture()){
int x, y;
getRes(&x, &y);
// Double buffer...
if(ltr_int_mmap_file(getMapFileName(), ltr_int_get_com_size() + x * y, &mmm)){
ltr_int_setCommand(&mmm, WAKEUP);
capture(&mmm);
ltr_int_unmap_file(&mmm);
}else{
ltr_int_log_message("Can't mmap!\n");
return EXIT_FAILURE;
}
}else{
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
bool ltr_int_init_tracking()
{
if(tracking_dbg_flag == DBG_CHECK){
tracking_dbg_flag = ltr_int_get_dbg_flag('t');
raw_dbg_flag = ltr_int_get_dbg_flag('r');
}
orientation = ltr_int_get_orientation();
if(orientation & ORIENT_FROM_BEHIND){
behind = true;
}else{
behind = false;
}
if(ltr_int_check_pose() == false){
ltr_int_log_message("Can't get pose setup!\n");
return false;
}
// filtered_bloblist.num_blobs = 3;
// filtered_bloblist.blobs = filtered_blobs;
// first_frame = true;
ltr_int_log_message("Tracking initialized!\n");
tracking_initialized = true;
init_recenter = true;
recenter = false;
return true;
}
bool ltr_int_register_slave(int socket, message_t &msg)
{
ltr_int_log_message("Trying to register slave!\n");
pthread_mutex_lock(&send_mx);
slaves.insert(std::pair<std::string, int>(msg.str, socket));
ltr_int_log_message("Slave with profile '%s' @socket %d registered!\n", msg.str, socket);
pthread_mutex_unlock(&send_mx);
//Make sure the new section is created if needed...
ltr_axes_t tmp_axes;
tmp_axes = NULL;
ltr_int_init_axes(&tmp_axes, msg.str);
ltr_int_close_axes(&tmp_axes);
if(save_prefs) {
ltr_int_log_message("Checking for changed prefs...\n");
if(ltr_int_need_saving()) {
ltr_int_log_message("Master is about to save changed preferences.\n");
ltr_int_save_prefs(NULL);
}
}
if(new_slave_hook != NULL) {
new_slave_hook(msg.str);
}
return true;
}
bool add_poll_desc(int fd) {
ltr_int_log_message("Adding fd %d\n", fd);
if(current_len >= max_len) {
if(max_len > 0) {
max_len *= 2;
descs = (struct pollfd*)realloc(descs, max_len * sizeof(struct pollfd));
if(descs) {
memset(descs + current_len, 0,
(max_len - current_len) * sizeof(struct pollfd));//???
}
} else {
max_len = 1;
descs = (struct pollfd*)malloc(max_len * sizeof(struct pollfd));
if(descs) {
memset(descs, 0, max_len * sizeof(struct pollfd));
}
}
if(descs == NULL) {
ltr_int_my_perror("m/re-alloc");
ltr_int_log_message("Can't alloc enough memory for the poll!\n");
exit(1);
}
}
descs[current_len].fd = fd;
descs[current_len].events = POLLIN;
descs[current_len].revents = 0;
++current_len;
return true;
}
bool get_game_data(const char *input_fname, const char *output_fname, bool from_update)
{
FILE *outfile = NULL;
if((outfile = (output_fname ? fopen(output_fname, "w") : stdout)) == NULL){
ltr_int_log_message("Can't open the output file '%s'!\n", output_fname);
return false;
}
if(!game_data_init(input_fname, from_update)){
ltr_int_log_message("Can't process the data file '%s'!\n", input_fname);
return false;
}
mxml_node_t *game;
const char *name;
const char *id;
for(game = mxmlFindElement(tree, tree, "Game", NULL, NULL, MXML_DESCEND);
game != NULL;
game = mxmlFindElement(game, tree, "Game", NULL, NULL, MXML_DESCEND)){
name = mxmlElementGetAttr(game, "Name");
id = mxmlElementGetAttr(game, "Id");
mxml_node_t *appid = mxmlFindElement(game, game, "ApplicationID", NULL, NULL, MXML_DESCEND);
if(appid == NULL){
fprintf(outfile, "%s \"%s\"\n", id, name);
}else{
fprintf(outfile, "%s \"%s\" (%s)\n", id, name, appid->child->value.text.string);
}
}
fclose(outfile);
game_data_close();
return true;
}
bool ltr_int_gui_lock(bool do_lock)
{
static const char *lockName = "ltr_server.lock";
if((pfSem == NULL) ) {
//just check...
switch(ltr_int_server_running_already(lockName, false, &pfSem, do_lock)) {
case 0:
return true;
break;
case 1:
ltr_int_log_message("Gui server running!");
return false;
break;
default:
ltr_int_log_message("Error locking gui server lock!");
return false;
break;
}
} else {
if(do_lock) {
return ltr_int_tryLockSemaphore(pfSem);
} else {
return ltr_int_testLockSemaphore(pfSem);
}
}
}
static bool claim_tir(int config, unsigned int interface)
{
ltr_int_log_message("Trying to claim TrackIR interface.\n");
if(libusb_claim_interface(handle, interface)){
ltr_int_log_message("Couldn't claim interface!\n");
interface_claimed = false;
return false;
}
ltr_int_log_message("TrackIR interface claimed.\n");
interface_claimed = true;
// if(libusb_reset_device(handle)){
// log_message("Couldn't reset device!\n");
// return false;
// }
int cfg;
ltr_int_log_message("Requesting TrackIR configuration.\n");
if(libusb_get_configuration(handle, &cfg)){
ltr_int_log_message("Can't get device configuration!\n");
return false;
}
ltr_int_log_message("TrackIR configuration received.\n");
if(cfg != config){
ltr_int_log_message("Device configuration is wrong!\n");
return false;
}
ltr_int_log_message("Device configuration is OK.\n");
return true;
}
WineLauncher::WineLauncher():winePath(QString::fromUtf8("")), available(false)
{
std::ostringstream s;
env = QProcessEnvironment::systemEnvironment();
if(!check()){
#ifdef DARWIN
winePath = QApplication::applicationDirPath()+QString::fromUtf8("/../wine/bin/");
QString libPath = QApplication::applicationDirPath()+QString::fromUtf8("/../wine/lib/");
available = true;
QString path = winePath + QString::fromUtf8(":") + env.value(QString::fromUtf8("PATH"));
s.str(std::string(""));
s<<"Using internal wine; adjusting env variables:"<<std::endl;
ltr_int_log_message(s.str().c_str());
envSet(QString::fromUtf8("PATH"), path);
envSet(QString::fromUtf8("WINESERVER"), winePath+QString::fromUtf8("wineserver"));
envSet(QString::fromUtf8("WINELOADER"), winePath+QString::fromUtf8("wine"));
envSet(QString::fromUtf8("WINEDLLPATH"), libPath+QString::fromUtf8("wine/fakedlls"));
envSet(QString::fromUtf8("DYLD_LIBRARY_PATH"), libPath);
envSet(QString::fromUtf8("DYLD_PRINT_ENV"), QString::fromUtf8("1"));
envSet(QString::fromUtf8("DYLD_PRINT_LIBRARIES"), QString::fromUtf8("1"));
envSet(QString::fromUtf8("WINEDEBUG"), QString::fromUtf8("+file,+seh,+tid,+process,+rundll,+module"));
#endif
}else{
available = true;
}
QObject::connect(&wine, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(finished(int, QProcess::ExitStatus)));
QObject::connect(&wine, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(error(QProcess::ProcessError)));
}
bool ltr_int_broadcast_pose(linuxtrack_full_pose_t &pose)
{
pthread_mutex_lock(&send_mx);
std::multimap<std::string, int>::iterator i;
int res;
bool checkSlaves = false;
//Send updated pose to all clients
//printf("Master: %g %g %g\n", pose.pose.raw_pitch, pose.pose.raw_yaw, pose.pose.raw_roll);
for(i = slaves.begin(); i != slaves.end();) {
res = ltr_int_send_data(i->second, &pose);
if(res == -EPIPE) {
ltr_int_log_message("Slave @socket %d left!\n", i->second);
close(i->second);
i->second = -1;
slaves.erase(i++);
checkSlaves = true;
} else {
++i;
}
}
if(checkSlaves && (slaves.size() == 0)) {
no_slaves = true;
}
pthread_mutex_unlock(&send_mx);
return true;
}
bool ltr_int_check_pose()
{
struct reflector_model_type rm;
if(ltr_int_model_changed(true)){
if(!ltr_int_get_model_setup(&rm)){
ltr_int_log_message("Can't get pose setup!\n");
return false;
}
ltr_int_log_message("Initializing model!\n");
if(!ltr_int_pose_init(rm)){
ltr_int_log_message("Can't initialize pose!\n");
return false;
}
}
return true;
}
void WineLauncher::envSet(const QString var, const QString val)
{
env.insert(var, val);
std::ostringstream s;
s<<" "<<var.toUtf8().constData()<<"='"<<val.toUtf8().constData()<<"'"<<std::endl;
ltr_int_log_message(s.str().c_str());
}
void print_descs(void)
{
nfds_t i;
for(i = 0; i < current_len; ++i) {
ltr_int_log_message("%ld: fd=%d, ev=%d, rev=%d\n", (long int)i,
descs[i].fd, descs[i].events, descs[i].revents);
}
}
static bool is_tir(libusb_device *dev, unsigned int devid)
{
struct libusb_device_descriptor desc;
//ltr_int_log_message("Checking, if device is Track IR.\n");
if(libusb_get_device_descriptor(dev, &desc)){
ltr_int_log_message("Error getting device descriptor!\n");
return false;
}
//ltr_int_log_message("Device descriptor received.\n");
if((desc.idVendor == 0x131D) && (desc.idProduct == devid)){
ltr_int_log_message("Device is a TrackIR (%04X:%04X).\n", desc.idVendor, desc.idProduct);
return true;
}else{
//ltr_int_log_message("Device is not a TrackIR(%04X:%04X).\n", desc.idVendor, desc.idProduct);
return false;
}
}
static bool open_master_comms(int *l_master_uplink, int *l_master_downlink)
{
ltr_int_log_message("Opening master comms!\n");
*l_master_uplink = ltr_int_open_fifo_for_writing(ltr_int_master_fifo_name(), true);
if(*l_master_uplink <= 0){
ltr_int_log_message("Couldn't open fifo to master!\n");
return false;
}
if((*l_master_downlink = ltr_int_open_slave_fifo(*l_master_uplink, ltr_int_slave_fifo_name(),
ltr_int_max_slave_fifos())) <= 0){
ltr_int_log_message("Couldn't pass master our fifo!\n");
close(*l_master_uplink);
*l_master_uplink = -1;
*l_master_downlink = -1;
return false;
}
ltr_int_log_message("Master comms opened => u -> %d d -> %d\n", *l_master_uplink, *l_master_downlink);
return true;
}
bool ltr_int_joy_enum_axes(ifc_type_t ifc, const char *name, axes_t *axes)
{
//printf("Going to enumerate axes (%d, %s)\n", ifc, name);
int fd = findJoystick(ifc, name);
if(fd < 0){
ltr_int_log_message("Problem finding device '%s', aborting axis enumeration.\n");
return false;
}
return enumerateAxes(ifc, fd, axes);
}
bool ltr_int_init_usb()
{
ltr_int_log_message("Initializing libusb.\n");
if(comm_dbg_flag == DBG_CHECK){
comm_dbg_flag = ltr_int_get_dbg_flag('u');
}
int res = libusb_init(&usb_context);
if(res != 0){
ltr_int_log_message("Problem initializing libusb!\n");
return false;
}
ltr_int_log_message("Libusb initialized successfuly.\n");
libusb_set_debug(usb_context, 0);
ltr_int_log_message("Libusb debug level set.\n");
return true;
}
int ltr_int_tir_found(bool *have_firmware, bool *have_permissions)
{
char *libname = NULL;
dbg_flag_type fakeusb_dbg_flag = ltr_int_get_dbg_flag('f');
if(fakeusb_dbg_flag == DBG_ON) {
libname = "libfakeusb";
ltr_int_log_message("Loading fakeusb!\n");
} else {
libname = "libltusb1";
}
if((libhandle = ltr_int_load_library(libname, functions)) == NULL) {
ltr_int_log_message("Failed to load the library '%s'! \n", libname);
return 0;
}
if(!ltr_int_init_usb()) {
ltr_int_log_message("Failed to initialize usb!\n");
return 0;
}
dev_found device = ltr_int_find_tir();
printf("Found device %X\n", device);
if(device & NOT_PERMITTED) {
device ^= NOT_PERMITTED;
*have_permissions = false;
} else {
*have_permissions = true;
}
if((device < TIR4) || (device == SMARTNAV3)) {
*have_firmware = true;
} else {
char *fw = ltr_int_find_firmware(device);
if(fw != NULL) {
free(fw);
*have_firmware = true;
} else {
*have_firmware = false;
}
}
ltr_int_finish_usb(-1);
ltr_int_unload_library(libhandle, functions);
libhandle = NULL;
return device;
}
int ltr_int_tracker_init(struct camera_control_block *ccb)
{
(void)ccb;
ltr_int_log_message("Initializing Wii!\n");
if(!ltr_int_wii_init_prefs()){
ltr_int_log_message("Can't initialize Wii preferences...\n");
return 1;
}
if(!ltr_int_initWiiCom(false, &mmm)){
ltr_int_log_message("Can't initialize communication with Wii...\n");
return 1;
}
ltr_int_resetFrameFlag(mmm);
ltr_int_wii_init_prefs();
ltr_int_setWiiIndication(mmm, get_indication());
ltr_int_resumeWii();
ltr_int_log_message("Init done!\n");
return 0;
}
void *ltr_int_delete_current(plist pl, iterator* i)
{
assert(i != NULL);
assert(i->parent != NULL);
assert(i->parent == pl);
if(ltr_int_is_empty(pl)) {
ltr_int_log_message("Attempted to delete from empty list!\n");
return NULL;
}
//iterator is already one element farther
list_element *current = NULL;
if((i->elem) == NULL) {
current = pl->tail;
} else if(i->elem == pl->head) {
current = pl->head;
} else {
current = i->elem->prev;
}
if(current == NULL) {
ltr_int_log_message("Can't determine which element to delete!\n");
return NULL;
}
if(pl->head == current) {
pl->head = current->next;
}
if(pl->tail == current) {
pl->tail = current->prev;
}
list_element *prev = current->prev;
list_element *next = current->next;
if(prev != NULL) {
prev->next = next;
}
if(next != NULL) {
next->prev = prev;
}
void *payload = current->payload;
free(current);
return payload;
}
static bool open_master_comms(int *l_master_uplink)
{
ltr_int_log_message("Opening master comms!\n");
//printf("open_master_comms\n");
*l_master_uplink = ltr_int_connect_to_socket(ltr_int_master_socket_name());
//printf("====================");
if(*l_master_uplink <= 0){
ltr_int_log_message("Couldn't connect to master's socket!\n");
return false;
}
ltr_int_log_message("Master comms opened => u -> %d\n", *l_master_uplink);
if(ltr_int_send_message_w_str(*l_master_uplink, CMD_NEW_SOCKET, 0, profile_name) != 0){
ltr_int_log_message("Master uplink doesn't seem to be working!\n");
return false;
}
ltr_int_log_message("Notification of the '%s' client sent to master!\n", profile_name);
return true;
}
static int update_absolute_pose(struct frame_type *frame)
{
static float c_pitch = 0.0f;
static float c_yaw = 0.0f;
static float c_roll = 0.0f;
static float c_tx = 0.0f;
static float c_ty = 0.0f;
static float c_tz = 0.0f;
//printf("Updating pose 1pt...\n");
if(!ltr_int_check_pose()){
return -1;
}
//printf("Updating pose...\n");
if(tracking_dbg_flag == DBG_ON){
unsigned int i;
for(i = 0; i < frame->bloblist.num_blobs; ++i){
ltr_int_log_message("*DBG_t* %d: %g %g %d\n", i, frame->bloblist.blobs[i].x, frame->bloblist.blobs[i].y,
frame->bloblist.blobs[i].score);
}
}
if(recenter){
c_pitch = frame->bloblist.blobs[0].y;
c_yaw = frame->bloblist.blobs[0].x;
c_roll = frame->bloblist.blobs[1].x;
c_tx = frame->bloblist.blobs[1].y;
c_ty = frame->bloblist.blobs[2].x;
c_tz = frame->bloblist.blobs[2].y;
recenter = false;
}
//double tmp_angles[3], tmp_translations[3];
pthread_mutex_lock(&pose_mutex);
current_pose.pose.raw_pitch = frame->bloblist.blobs[0].y - c_pitch;
current_pose.pose.raw_yaw = frame->bloblist.blobs[0].x - c_yaw;
current_pose.pose.raw_roll = frame->bloblist.blobs[1].x - c_roll;
current_pose.pose.raw_tx = frame->bloblist.blobs[1].y - c_tx;
current_pose.pose.raw_ty = frame->bloblist.blobs[2].x - c_ty;
current_pose.pose.raw_tz = frame->bloblist.blobs[2].y - c_tz;
current_pose.abs_pose.abs_pitch = frame->bloblist.blobs[0].y;
current_pose.abs_pose.abs_yaw = frame->bloblist.blobs[0].x;
current_pose.abs_pose.abs_roll = frame->bloblist.blobs[1].x;
current_pose.abs_pose.abs_tx = frame->bloblist.blobs[1].y;
current_pose.abs_pose.abs_ty = frame->bloblist.blobs[2].x;
current_pose.abs_pose.abs_tz = frame->bloblist.blobs[2].y;
pthread_mutex_unlock(&pose_mutex);
//printf("Pose updated => rp: %g, ry: %g...\n", current_pose.raw_pitch, current_pose.raw_yaw);
return 0;
}
static bool ltr_int_try_start_master(int *l_master_uplink)
{
int master_restart_retries = master_retries;
while(master_restart_retries > 0){
close_master_comms(l_master_uplink);
if(ltr_int_gui_lock(false)){
ltr_int_log_message("GUI lock retrieved, no GUI running.\n");
start_master();
usleep(100);
--master_restart_retries;
}else{
master_restart_retries = master_retries;
}
if(open_master_comms(l_master_uplink)){
ltr_int_log_message("Master is responding!\n");
return true;
}
sleep(1);
}
return false;
}
static int ltr_int_open_slave_fifo(int l_master_uplink, const char *name_template, int max_fifos)
{
ltr_int_log_message("Registering slave fifo @ fd%d...\n", l_master_uplink);
char *data_fifo_name = NULL;
//Open the data passing fifo and pass it to the master...
int fifo_number = -1;
int l_master_downlink = ltr_int_open_unique_fifo(&data_fifo_name, &fifo_number, name_template,
max_fifos, &slave_lock);
ltr_int_log_message("Trying to open unique fifo %s => %d\n", data_fifo_name, l_master_downlink);
free(data_fifo_name);
if(l_master_downlink <= 0){
ltr_int_log_message("Failed to open master downlink!\n");
return -1;
}
if(ltr_int_send_message_w_str(l_master_uplink, CMD_NEW_FIFO, fifo_number, profile_name) == 0){
ltr_int_log_message("Master downlink (%d) OK!\n", l_master_downlink);
return l_master_downlink;
}else{
ltr_int_log_message("Master uplink not working!\n");
close(l_master_downlink);
return -1;
}
}
PrefProxy::PrefProxy()
{
if(ltr_int_read_prefs(NULL, false)){
checkPrefix(true);
return;
}
ltr_int_log_message("Pref file not found, trying linuxtrack.conf\n");
if(ltr_int_read_prefs("linuxtrack.conf", false)){
ltr_int_prefs_changed();
checkPrefix(true);
return;
}
ltr_int_log_message("Couldn't load preferences (GUI), copying default!\n");
if(!makeRsrcDir()){
throw;
}
if(!copyDefaultPrefs()){
throw;
}
ltr_int_new_prefs();
ltr_int_read_prefs(NULL, true);
checkPrefix(true);
}
bool ltr_int_send_data(int out_ep, unsigned char data[], size_t size)
{
int res, transferred;
if(comm_dbg_flag == DBG_ON){
ltr_int_log_packet("out", data, size);
}
//ltr_int_log_message("Sending bulk data.\n");
if((res = libusb_bulk_transfer(handle, out_ep, data, size, &transferred, 500))){
ltr_int_log_message("Problem writing data to TIR@ep %d! %d - %d transferred\n",
out_ep, res, transferred);
return false;
}
//ltr_int_log_message("Bulk data sent.\n");
return true;
}
joystickNames_t *ltr_int_joy_enum_joysticks(ifc_type_t ifc)
{
joystickNames_t *jsNames = (joystickNames_t *)malloc(sizeof(joystickNames_t));
if(jsNames == NULL){
return NULL;
}
jsNames->nameList = NULL;
jsNames->namesFound = 0;
enumerateJoyFiles(ifc, "/dev/input", storeJoyNames, (void *)jsNames);
size_t i;
for(i = 0; i < jsNames->namesFound; ++i){
ltr_int_log_message("Found joystick named '%s'.\n", jsNames->nameList[i]);
}
return jsNames;
}
