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; }