int dbg_append(char* name) { int x=0; int size, fd, rc; char tmp[CHUNKSIZE+1]; fd = open(name,O_RDONLY); if (fd<0) { DEBUGF("Failed opening file\n"); return -1; } size = lseek(fd, 0, SEEK_END); DEBUGF("File is %d bytes\n", size); x = size / CHUNKSIZE; LDEBUGF("Check base is %x (%d)\n",x,size); if (close(fd) < 0) return -1; fd = open(name,O_RDWR|O_APPEND); if (fd<0) { DEBUGF("Failed opening file\n"); return -1; } sprintf(tmp,"%c%06x,",name[1],x++); rc = write(fd, tmp, 8); if ( rc < 0 ) panicf("Failed writing data\n"); return close(fd); }
void SegmentationImpl::computeSolution() { if (!datatermAvailable()) { LDEBUGF("No dataterm available. Cannot compute solution."); return; } if (!weightAvailable()) { LDEBUGF("No weight available. Cannot compute solution."); return; } tvsolver()->computeSolution(dataterm(), weight(), settings()->numLabels(), feedback_.get()); if (tvsolver()->solutionAvailable()) { LINFOF("Computed solution"); } else { LWARNINGF("Failed to compute solution."); } }
int dbg_chkfile(char* name, int size) { char text[81920]; int i; int x=0; int pos = 0; int block=0; int fd = open(name,O_RDONLY); if (fd<0) { DEBUGF("Failed opening file\n"); return -1; } size = lseek(fd, 0, SEEK_END); DEBUGF("File is %d bytes\n", size); /* random start position */ if ( size ) pos = ((int)rand() % size) & ~7; lseek(fd, pos, SEEK_SET); x = pos / CHUNKSIZE; LDEBUGF("Check base is %x (%d)\n",x,pos); while (1) { int rc = read(fd, text, sizeof text); DEBUGF("read %d bytes\n",rc); if (rc < 0) { panicf("Failed reading data\n"); } else { char tmp[CHUNKSIZE+1]; if (!rc) break; for (i=0; i<rc/CHUNKSIZE; i++ ) { sprintf(tmp,"%c%06x,",name[1],x++); if (strncmp(text+i*CHUNKSIZE,tmp,CHUNKSIZE)) { int idx = pos + block*sizeof(text) + i*CHUNKSIZE; DEBUGF("Mismatch in byte 0x%x (byte 0x%x of sector 0x%x)." "\nExpected %.8s found %.8s\n", idx, idx % SECTOR_SIZE, idx / SECTOR_SIZE, tmp, text+i*CHUNKSIZE); DEBUGF("i=%x, idx=%x\n",i,idx); dbg_dump_buffer(text+i*CHUNKSIZE - 0x20, 0x40, idx - 0x20); return -1; } } } block++; } return close(fd); }
int dbg_mkfile(char* name, int num) { char text[BUFSIZE+1]; int i; int fd; int x=0; bool stop = false; fd = creat(name,O_WRONLY); if (fd<0) { DEBUGF("Failed creating file\n"); return -1; } num *= 1024; while ( num ) { int rc; int len = num > BUFSIZE ? BUFSIZE : num; for (i=0; i<len/CHUNKSIZE; i++ ) sprintf(text+i*CHUNKSIZE,"%c%06x,",name[1],x++); rc = write(fd, text, len); if ( rc < 0 ) { DEBUGF("Failed writing data\n"); return -1; } else if ( rc == 0 ) { DEBUGF("No space left\n"); return -2; } else DEBUGF("wrote %d bytes\n",rc); num -= len; if ( !num ) { if ( stop ) break; /* add a random number of chunks to test byte-copy code */ num = ((int) rand() % SECTOR_SIZE) & ~7; LDEBUGF("Adding random size %d\n",num); stop = true; } } return close(fd); }
void SegmentationImpl::computeVisualization() { if (!solutionAvailable()) { LDEBUGF("No solution available. Cannot compute visualization."); return; } if (!inputImageColorAvailable()) { LDEBUGF("No inputImageColor available. Cannot compute visualization."); return; } if (!labelsAvailable()) { LDEBUGF("No labels available. Cannot compute visualization."); return; } tvvisualizer()->computeVisualization(solution(), inputImageGroundTruth(), inputImageColor(), labels(), settings()->numLabels(), feedback_.get()); if (tvvisualizer()->visualizationAvailable()) { LINFOF("Computed visualization"); } else { LWARNINGF("Failed to compute visualization."); } }
void SegmentationImpl::computeKMeans() { const int n = settings()->numLabels(); if (!inputImageColorAvailable()) { LDEBUGF("No image available; Cannot compute %d means", n); return; } kmeans()->computeMeans(inputImageColor(), n); if (kmeans()->maxNumMeans() >= n) { LINFOF("Computed %d means successfully", n); } else { LWARNINGF("Failed to compute %d means", n); } }
void SegmentationImpl::computeDataterm() { if (!inputImageColorAvailable()) { LDEBUGF("No image available. Cannot compute dataterm."); return; } tvdataterm()->computeDataterm(inputImageColor(), inputImageDepth(), inputSettings()->intrinsics(), scribbles(), settings()->numLabels(), feedback_.get()); if (tvdataterm()->datatermAvailable()) { LINFOF("Computed dataterm"); } else { LWARNINGF("Failed to compute dataterm."); } }
static int open_internal(const char* pathname, int flags, bool use_cache) { DIR_UNCACHED* dir; struct dirent_uncached* entry; int fd; char pathnamecopy[MAX_PATH]; char* name; struct filedesc* file = NULL; int rc; #ifndef HAVE_DIRCACHE (void)use_cache; #endif LDEBUGF("open(\"%s\",%d)\n",pathname,flags); if ( pathname[0] != '/' ) { DEBUGF("'%s' is not an absolute path.\n",pathname); DEBUGF("Only absolute pathnames supported at the moment\n"); errno = EINVAL; return -1; } /* find a free file descriptor */ for ( fd=0; fd<MAX_OPEN_FILES; fd++ ) if ( !openfiles[fd].busy ) break; if ( fd == MAX_OPEN_FILES ) { DEBUGF("Too many files open\n"); errno = EMFILE; return -2; } file = &openfiles[fd]; memset(file, 0, sizeof(struct filedesc)); if (flags & (O_RDWR | O_WRONLY)) { file->write = true; if (flags & O_TRUNC) file->trunc = true; } file->busy = true; #ifdef HAVE_DIRCACHE if (dircache_is_enabled() && !file->write && use_cache) { const struct dircache_entry *ce; # ifdef HAVE_MULTIVOLUME int volume = strip_volume(pathname, pathnamecopy); # endif ce = dircache_get_entry_ptr(pathname); if (!ce) { errno = ENOENT; file->busy = false; return -7; } fat_open(IF_MV2(volume,) ce->startcluster, &(file->fatfile), NULL); file->size = ce->size; file->attr = ce->attribute; file->cacheoffset = -1; file->fileoffset = 0; return fd; } #endif strlcpy(pathnamecopy, pathname, sizeof(pathnamecopy)); /* locate filename */ name=strrchr(pathnamecopy+1,'/'); if ( name ) { *name = 0; dir = opendir_uncached(pathnamecopy); *name = '/'; name++; } else { dir = opendir_uncached("/"); name = pathnamecopy+1; } if (!dir) { DEBUGF("Failed opening dir\n"); errno = EIO; file->busy = false; return -4; } if(name[0] == 0) { DEBUGF("Empty file name\n"); errno = EINVAL; file->busy = false; closedir_uncached(dir); return -5; } /* scan dir for name */ while ((entry = readdir_uncached(dir))) { if ( !strcasecmp(name, entry->d_name) ) { fat_open(IF_MV2(dir->fatdir.file.volume,) entry->startcluster, &(file->fatfile), &(dir->fatdir)); file->size = file->trunc ? 0 : entry->size; file->attr = entry->attribute; break; } }
int open(const char* pathname, int flags) { DIR* dir; struct dirent* entry; int fd; char pathnamecopy[MAX_PATH]; char* name; struct filedesc* file = NULL; int rc; LDEBUGF("open(\"%s\",%d)\n",pathname,flags); if ( pathname[0] != '/' ) { DEBUGF("'%s' is not an absolute path.\n",pathname); DEBUGF("Only absolute pathnames supported at the moment\n"); errno = EINVAL; return -1; } /* find a free file descriptor */ for ( fd=0; fd<MAX_OPEN_FILES; fd++ ) if ( !openfiles[fd].busy ) break; if ( fd == MAX_OPEN_FILES ) { DEBUGF("Too many files open\n"); errno = EMFILE; return -2; } file = &openfiles[fd]; memset(file, 0, sizeof(struct filedesc)); if (flags & (O_RDWR | O_WRONLY)) { file->write = true; if (flags & O_TRUNC) file->trunc = true; } file->busy = true; strncpy(pathnamecopy,pathname,sizeof(pathnamecopy)); pathnamecopy[sizeof(pathnamecopy)-1] = 0; /* locate filename */ name=strrchr(pathnamecopy+1,'/'); if ( name ) { *name = 0; dir = opendir(pathnamecopy); *name = '/'; name++; } else { dir = opendir("/"); name = pathnamecopy+1; } if (!dir) { DEBUGF("Failed opening dir\n"); errno = EIO; file->busy = false; return -4; } if(name[0] == 0) { DEBUGF("Empty file name\n"); errno = EINVAL; file->busy = false; closedir(dir); return -5; } /* scan dir for name */ while ((entry = readdir(dir))) { if ( !strcasecmp(name, entry->d_name) ) { fat_open(IF_MV2(dir->fatdir.file.volume,) entry->startcluster, &(file->fatfile), &(dir->fatdir)); file->size = file->trunc ? 0 : entry->size; file->attr = entry->attribute; break; } }