static int pylog_initobj(PyObject *s, PyObject *args, PyObject *kwds) { PyLogObject *self = (PyLogObject *)s; static char *keywords[] = { "filename", "mode", 0 }; char *filename = NULL; char *mode = "r"; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|s", keywords, &filename, &mode)) return -1; if (!strcmp (mode, "r")) { self->mode = 'r'; } else if (!strcmp (mode, "w")) { self->mode = 'w'; } else { PyErr_SetString (PyExc_ValueError, "invalid mode"); return -1; } if (self->eventlog) { lcm_eventlog_destroy (self->eventlog); } self->eventlog = lcm_eventlog_create (filename, mode); if (!self->eventlog) { PyErr_SetFromErrno (PyExc_IOError); return -1; } return 0; }
int main(int argc, char **argv) { if(argc < 2) { fprintf(stderr, "usage: example1-poses <logfile>\n"); return 1; } lcm_eventlog_t *log = lcm_eventlog_create(argv[1], "r"); if(!log) { fprintf(stderr, "error opening log file\n"); return 1; } printf("# utime x y z x' y' z'\n"); lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(log); while(event) { if(!strcmp(event->channel, "POSE")) { lcmtypes_pose_t pose; lcmtypes_pose_t_decode(event->data, 0, event->datalen, &pose); printf("%lld %f %f %f %f %f %f\n", (long long)pose.utime, pose.pos[0], pose.pos[1], pose.pos[2], pose.vel[0], pose.vel[1], pose.vel[2]); lcmtypes_pose_t_decode_cleanup(&pose); } lcm_eventlog_free_event(event); event = lcm_eventlog_read_next_event(log); } lcm_eventlog_destroy(log); return 0; }
int main(int argc, char **argv) { if(argc < 2) { fprintf(stderr, "usage: example3-gps <logfile>\n"); return 1; } lcm_eventlog_t *log = lcm_eventlog_create(argv[1], "r"); if(!log) { fprintf(stderr, "error opening log file\n"); return 1; } lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(log); while(event) { if(!strcmp(event->channel, "GPS_TO_LOCAL")) { lcmtypes_gps_to_local_t gps; lcmtypes_gps_to_local_t_decode(event->data, 0, event->datalen, &gps); printf("%lld %.10f %.10f %f %f\n", (long long)gps.utime, gps.lat_lon_el_theta[0], gps.lat_lon_el_theta[1], gps.lat_lon_el_theta[2], gps.lat_lon_el_theta[3]); lcmtypes_gps_to_local_t_decode_cleanup(&gps); } lcm_eventlog_free_event(event); event = lcm_eventlog_read_next_event(log); } lcm_eventlog_destroy(log); return 0; }
LogFile::LogFile(const std::string & path, const std::string & mode) : eventlog(lcm_eventlog_create(path.c_str(), mode.c_str())), last_event(NULL) { }
int main(int argc, char **argv) { int verbose = 0; int filterChannels =0; char *pattern = strdup(".*"); char *dest_fname = NULL; int64_t start_utime = 0; int64_t end_utime = -1; int have_end_utime = 0; int invert_regex = 0; char *optstring = "hc:vs:e:i"; int c; while ((c = getopt_long(argc, argv, optstring, NULL, 0)) >= 0) { switch (c) { case 'h': usage(); break; case 's': { char *eptr = NULL; double start_time = strtod(optarg, &eptr); if (*eptr != 0) usage(); start_utime = (int64_t) (start_time * 1000000); } break; case 'e': { char *eptr = NULL; double end_time = strtod(optarg, &eptr); if (*eptr != 0) usage(); end_utime = (int64_t) (end_time * 1000000); have_end_utime = 1; } break; case 'i': invert_regex = 1; filterChannels = 1; break; case 'c': free(pattern); pattern = strdup(optarg); filterChannels = 1; break; case 'v': verbose = 1; break; default: usage(); break; }; } if (start_utime < 0 || (have_end_utime && end_utime < start_utime)) usage(); if (optind > argc - 3) usage(); regex_t preg; if (0 != regcomp(&preg, pattern, REG_NOSUB | REG_EXTENDED)) { fprintf(stderr, "bad regex\n"); exit(1); } int num_src_logs = argc - optind - 1; fprintf(stderr, "Splicing together %d logs\n", num_src_logs); lcm_eventlog_t *src_logs[num_src_logs]; for (int i = 0; i < argc - optind - 1; i++) { char * src_fname = argv[optind + i]; src_logs[i] = lcm_eventlog_create(src_fname, "r"); if (!src_logs[i]) { perror("Unable to open source logfile"); for (int j = 0; j < i; j++) lcm_eventlog_destroy(src_logs[j]); regfree(&preg); return 1; } } dest_fname = argv[argc - 1]; lcm_eventlog_t *dst_log = lcm_eventlog_create(dest_fname, "w"); if (!dst_log) { perror("Unable to open destination logfile"); for (int i = 0; i < num_src_logs; i++) lcm_eventlog_destroy(src_logs[i]); regfree(&preg); return 1; } GHashTable *counts = g_hash_table_new_full(g_str_hash, g_str_equal, free, free); int nwritten = 0; int have_first_event_timestamp = 0; int64_t first_event_timestamp = -1; lcm_eventlog_event_t *events[num_src_logs]; for (int i = 0; i < num_src_logs; i++) events[i] = lcm_eventlog_read_next_event(src_logs[i]); while (1) { lcm_eventlog_event_t *event; int mind = -1; int64_t mtime = INT64_MAX; for (int i = 0; i < num_src_logs; i++) { if (events[i] == NULL) continue; else if (events[i]->timestamp < mtime) { mtime = events[i]->timestamp; mind = i; } } if (mind < 0) //all are null break; event = events[mind]; events[mind] = lcm_eventlog_read_next_event(src_logs[mind]); if (!have_first_event_timestamp) { first_event_timestamp = event->timestamp; have_first_event_timestamp = 1; } int64_t elapsed = event->timestamp - first_event_timestamp; if (elapsed < start_utime) { lcm_eventlog_free_event(event); continue; } if (have_end_utime && elapsed > end_utime) { lcm_eventlog_free_event(event); break; } int copy_to_dest = 1; if (filterChannels) { int regmatch = regexec(&preg, event->channel, 0, NULL, 0); copy_to_dest = (regmatch == 0 && !invert_regex) || (regmatch != 0 && invert_regex); } if (copy_to_dest) { lcm_eventlog_write_event(dst_log, event); nwritten++; if (verbose) { int *count = g_hash_table_lookup(counts, event->channel); if (!count) { count = (int*) malloc(sizeof(int)); *count = 1; g_hash_table_insert(counts, strdup(event->channel), count); printf("matched channel %s\n", event->channel); } else { *count += 1; } } } lcm_eventlog_free_event(event); } if (verbose) { g_hash_table_foreach(counts, _verbose_entry_summary, NULL); printf("=====\n"); printf("Events written: %d\n", nwritten); } regfree(&preg); for (int i = 0; i < num_src_logs; i++) lcm_eventlog_destroy(src_logs[i]); lcm_eventlog_destroy(dst_log); g_hash_table_destroy(counts); return 0; }
int main(int argc, char **argv) { int verbose = 0; char *pattern = g_strdup(".*"); char *source_fname = NULL; char *dest_fname = NULL; int64_t start_utime = 0; int64_t end_utime = -1; int have_end_utime = 0; int invert_regex = 0; char *optstring = "hc:vs:e:i"; int c; while ((c = getopt_long(argc, argv, optstring, NULL, 0)) >= 0) { switch (c) { case 'h': usage(); break; case 's': { char *eptr = NULL; double start_time = strtod(optarg, &eptr); if (*eptr != 0) usage(); start_utime = (int64_t)(start_time * 1000000); } break; case 'e': { char *eptr = NULL; double end_time = strtod(optarg, &eptr); if (*eptr != 0) usage(); end_utime = (int64_t)(end_time * 1000000); have_end_utime = 1; } break; case 'i': invert_regex = 1; break; case 'c': g_free(pattern); pattern = g_strdup(optarg); break; case 'v': verbose = 1; break; default: usage(); break; }; } if (start_utime < 0 || (have_end_utime && end_utime < start_utime)) usage(); if (optind != argc - 2) usage(); GRegex *regex; GError *rerr = NULL; regex = g_regex_new(pattern, (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, &rerr); if (rerr) { fprintf(stderr, "bad regex\n"); exit(1); } source_fname = argv[argc - 2]; dest_fname = argv[argc - 1]; lcm_eventlog_t *src_log = lcm_eventlog_create(source_fname, "r"); if (!src_log) { perror("Unable to open source logfile"); g_regex_unref(regex); return 1; } lcm_eventlog_t *dst_log = lcm_eventlog_create(dest_fname, "w"); if (!dst_log) { perror("Unable to open destination logfile"); lcm_eventlog_destroy(src_log); g_regex_unref(regex); return 1; } GHashTable *counts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free); int nwritten = 0; int have_first_event_timestamp = 0; int64_t first_event_timestamp = 0; for (lcm_eventlog_event_t *event = lcm_eventlog_read_next_event(src_log); event != NULL; event = lcm_eventlog_read_next_event(src_log)) { if (!have_first_event_timestamp) { first_event_timestamp = event->timestamp; have_first_event_timestamp = 1; } int64_t elapsed = event->timestamp - first_event_timestamp; if (elapsed < start_utime) { lcm_eventlog_free_event(event); continue; } if (have_end_utime && elapsed > end_utime) { lcm_eventlog_free_event(event); break; } int regmatch = g_regex_match(regex, event->channel, (GRegexMatchFlags) 0, NULL); if ((!regmatch && invert_regex) || (regmatch && !invert_regex)) { lcm_eventlog_write_event(dst_log, event); nwritten++; if (verbose) { int *count = (int *) g_hash_table_lookup(counts, event->channel); if (!count) { count = (int *) malloc(sizeof(int)); *count = 1; g_hash_table_insert(counts, g_strdup(event->channel), count); printf("matched channel %s\n", event->channel); } else { *count += 1; } } } lcm_eventlog_free_event(event); } if (verbose) { g_hash_table_foreach(counts, _verbose_entry_summary, NULL); printf("=====\n"); printf("Events written: %d\n", nwritten); } g_regex_unref(regex); lcm_eventlog_destroy(src_log); lcm_eventlog_destroy(dst_log); g_hash_table_destroy(counts); return 0; }
static lcm_provider_t * lcm_logprov_create (lcm_t * parent, const char *target, const GHashTable *args) { if (!target || !strlen (target)) { fprintf (stderr, "Error: Missing filename\n"); return NULL; } lcm_logprov_t * lr = (lcm_logprov_t *) calloc (1, sizeof (lcm_logprov_t)); lr->lcm = parent; lr->filename = strdup(target); lr->speed = 1; lr->next_clock_time = -1; lr->start_timestamp = -1; g_hash_table_foreach ((GHashTable*) args, new_argument, lr); dbg (DBG_LCM, "Initializing LCM log provider context...\n"); dbg (DBG_LCM, "Filename %s\n", lr->filename); if(lcm_internal_pipe_create(lr->notify_pipe) != 0) { perror(__FILE__ " - pipe (notify)"); lcm_logprov_destroy (lr); return NULL; } if(lcm_internal_pipe_create(lr->timer_pipe) != 0) { perror(__FILE__ " - pipe (timer)"); lcm_logprov_destroy (lr); return NULL; } //fcntl (lcm->notify_pipe[1], F_SETFL, O_NONBLOCK); if (!lr->writer) { lr->log = lcm_eventlog_create (lr->filename, "r"); } else { lr->log = lcm_eventlog_create (lr->filename, "w"); } if (!lr->log) { fprintf (stderr, "Error: Failed to open %s: %s\n", lr->filename, strerror (errno)); lcm_logprov_destroy (lr); return NULL; } // only start the reader thread if not in write mode if (!lr->writer){ if (load_next_event (lr) < 0) { fprintf (stderr, "Error: Failed to read first event from log\n"); lcm_logprov_destroy (lr); return NULL; } /* Start the reader thread */ lr->timer_thread = g_thread_create (timer_thread, lr, TRUE, NULL); if (!lr->timer_thread) { fprintf (stderr, "Error: LCM failed to start timer thread\n"); lcm_logprov_destroy (lr); return NULL; } lr->thread_created = 1; if(lcm_internal_pipe_write(lr->notify_pipe[1], "+", 1) < 0) { perror(__FILE__ " - write (reader create)"); } if(lr->start_timestamp > 0){ dbg (DBG_LCM, "Seeking to timestamp: %lld\n", (long long)lr->start_timestamp); lcm_eventlog_seek_to_timestamp(lr->log, lr->start_timestamp); } } return lr; }
static int open_logfile(logger_t* logger) { // maybe run the filename through strftime if (logger->use_strftime) { char new_prefix[PATH_MAX]; time_t now = time (NULL); strftime(new_prefix, sizeof(new_prefix), logger->input_fname, localtime(&now)); // If auto-increment is enabled and the strftime-formatted filename // prefix has changed, then reset the auto-increment counter. if(logger->auto_increment && strcmp(new_prefix, logger->fname_prefix)) logger->next_increment_num = 0; strcpy(logger->fname_prefix, new_prefix); } else { strcpy(logger->fname_prefix, logger->input_fname); } if (logger->auto_increment) { /* Loop through possible file names until we find one that doesn't * already exist. This way, we never overwrite an existing file. */ do { snprintf(logger->fname, sizeof(logger->fname), "%s.%02d", logger->fname_prefix, logger->next_increment_num); logger->next_increment_num++; } while(g_file_test(logger->fname, G_FILE_TEST_EXISTS)); if (errno != ENOENT) { perror ("Error: checking for previous logs"); return 1; } } else { strcpy(logger->fname, logger->fname_prefix); if (! logger->force_overwrite) { if (g_file_test(logger->fname, G_FILE_TEST_EXISTS)) { fprintf (stderr, "Refusing to overwrite existing file \"%s\"\n", logger->fname); return 1; } } } // create directories if needed char *dirpart = g_path_get_dirname (logger->fname); if (! g_file_test (dirpart, G_FILE_TEST_IS_DIR)) { mkdir_with_parents (dirpart, 0755); } g_free (dirpart); fprintf (stderr, "Opening log file \"%s\"\n", logger->fname); // open output file logger->log = lcm_eventlog_create(logger->fname, "w"); if (logger->log == NULL) { perror ("Error: fopen failed"); return 1; } return 0; }