void
progressbar_tick(int64_t current, int64_t total)
{
int percent;
if (!quiet && progress_started) {
if (isatty(STDOUT_FILENO))
draw_progressbar(current, total);
else {
if (progress_interrupted) {
printf("%s...", progress_message);
} else if (!getenv("NO_TICK")){
percent = (total != 0) ? (current * 100. / total) : 100;
if (last_progress_percent / 10 < percent / 10) {
last_progress_percent = percent;
printf(".");
fflush(stdout);
}
}
if (current >= total)
progressbar_stop();
}
}
progress_interrupted = false;
}
static void
vgatext_progressbar_stop()
{
extern void progressbar_stop(void);
if (vgatext_silent == 1) {
vgatext_silent = 0;
progressbar_stop();
}
}
//Creates a list of times which the aubio onset detector thinks are note onset times for the audio Denemo->si->recording
//Result is placed in Denemo->si->note_onsets
void
generate_note_onsets (void)
{
DenemoRecording *audio = Denemo.project->movement->recording;
gint channels = audio->channels;
smpl_t threshold = 0.3;
smpl_t silence = -90.;
uint_t buffer_size = 1024;
uint_t overlap_size = 512;
uint_t samplerate = 44100;
aubio_onset_t *o = new_aubio_onset("default",
buffer_size, overlap_size, samplerate);
fvec_t *ibuf = new_fvec (overlap_size);
fvec_t *onset = new_fvec (2);
unsigned int pos = 0; /*frames%dspblocksize */
unsigned int i; /*channels */
unsigned int j; /*frames */
busy_cursor (Denemo.notebook);
gtk_window_set_modal (progressbar (_("Analysing Audio"), NULL), TRUE);
rewind_audio ();
if (audio->notes)
{
g_list_free_full (audio->notes, g_free);
audio->notes = NULL;
}
for (j = 0; j < (unsigned) audio->nframes; j++)
{
sf_read_float (audio->sndfile, ibuf->data + pos, 2); //g_debug("\t%f", ibuf->data[0][pos]);
if (pos == overlap_size - 1)
{
/* block loop */
gtk_main_iteration_do (FALSE);
aubio_onset_do (o, ibuf, onset);
while (gtk_events_pending ())
gtk_main_iteration ();
if(onset->data[0] != 0) {
DenemoRecordedNote *note = g_malloc0(sizeof(DenemoRecordedNote));
note->timing = aubio_onset_get_last(o);/* aubio_onset_get_delay_s(o) for seconds */
audio->notes = g_list_append (audio->notes, note);
}
pos = -1; /* so it will be zero next j loop */
} /* end of if pos==overlap_size-1 */
pos++;
}
del_aubio_onset (o);
del_fvec (ibuf);
del_fvec (onset);
aubio_cleanup ();
progressbar_stop ();
normal_cursor (Denemo.notebook);
}
static void
draw_progressbar(int64_t current, int64_t total)
{
int percent;
int64_t transferred;
time_t elapsed = 0, now = 0;
char buf[8];
int64_t bytes_left;
int cur_speed;
int hours, minutes, seconds;
float age_factor;
if (!progress_started) {
progressbar_stop();
return;
}
if (progress_debit) {
now = time(NULL);
elapsed = (now >= last_update) ? now - last_update : 0;
}
percent = (total != 0) ? (current * 100. / total) : 100;
/**
* Wait for interval for debit bars to keep calc per second.
* If not debit, show on every % change, or if ticking after
* an interruption (which removed our progressbar output).
*/
if (current >= total || (progress_debit && elapsed >= 1) ||
(!progress_debit &&
(percent != last_progress_percent || progress_interrupted))) {
last_progress_percent = percent;
printf("\r%s: %3d%%", progress_message, percent);
if (progress_debit) {
transferred = current - last_tick;
last_tick = current;
bytes_left = total - current;
if (bytes_left <= 0) {
elapsed = now - begin;
/* Always show at least 1 second at end. */
if (elapsed == 0)
elapsed = 1;
/* Calculate true total speed when done */
transferred = total;
bytes_per_second = 0;
}
if (elapsed != 0)
cur_speed = (transferred / elapsed);
else
cur_speed = transferred;
#define AGE_FACTOR_SLOW_START 3
if (now - begin <= AGE_FACTOR_SLOW_START)
age_factor = 0.4;
else
age_factor = 0.9;
if (bytes_per_second != 0) {
bytes_per_second =
(bytes_per_second * age_factor) +
(cur_speed * (1.0 - age_factor));
} else
bytes_per_second = cur_speed;
humanize_number(buf, sizeof(buf),
current,"B", HN_AUTOSCALE, HN_IEC_PREFIXES);
printf(" %*s", (int)sizeof(buf), buf);
if (bytes_left > 0)
format_rate_SI(buf, sizeof(buf), transferred);
else /* Show overall speed when done */
format_rate_SI(buf, sizeof(buf),
bytes_per_second);
printf(" %s/s ", buf);
if (!transferred)
stalled += elapsed;
else
stalled = 0;
if (stalled >= STALL_TIME)
printf(" - stalled -");
else if (bytes_per_second == 0 && bytes_left > 0)
printf(" --:-- ETA");
else {
if (bytes_left > 0)
seconds = bytes_left / bytes_per_second;
else
seconds = elapsed;
hours = seconds / 3600;
seconds -= hours * 3600;
minutes = seconds / 60;
seconds -= minutes * 60;
if (hours != 0)
printf("%02d:%02d:%02d", hours,
minutes, seconds);
else
printf(" %02d:%02d", minutes, seconds);
if (bytes_left > 0)
printf(" ETA");
else
printf(" ");
}
last_update = now;
}
fflush(stdout);
}
if (current >= total)
progressbar_stop();
}
int
exec_check(int argc, char **argv)
{
struct pkg *pkg = NULL;
struct pkgdb_it *it = NULL;
struct pkgdb *db = NULL;
struct sbuf *msg = NULL;
match_t match = MATCH_EXACT;
int flags = PKG_LOAD_BASIC;
int ret, rc = EX_OK;
int ch;
bool dcheck = false;
bool checksums = false;
bool recompute = false;
bool reanalyse_shlibs = false;
bool noinstall = false;
int nbpkgs = 0;
int i, processed, total = 0;
int verbose = 0;
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "shlibs", no_argument, NULL, 'B' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "dependencies", no_argument, NULL, 'd' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "dry-run", no_argument, NULL, 'n' },
{ "recompute", no_argument, NULL, 'r' },
{ "checksums", no_argument, NULL, 's' },
{ "verbose", no_argument, NULL, 'v' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
struct deps_head dh = STAILQ_HEAD_INITIALIZER(dh);
processed = 0;
while ((ch = getopt_long(argc, argv, "+aBCdginrsvxy", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'B':
reanalyse_shlibs = true;
flags |= PKG_LOAD_FILES;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'd':
dcheck = true;
flags |= PKG_LOAD_DEPS;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'n':
noinstall = true;
break;
case 'r':
recompute = true;
flags |= PKG_LOAD_FILES;
break;
case 's':
checksums = true;
flags |= PKG_LOAD_FILES;
break;
case 'v':
verbose = 1;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_check();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
/* Default to all packages if no pkg provided */
if (argc == 0 && (dcheck || checksums || recompute || reanalyse_shlibs)) {
match = MATCH_ALL;
} else if ((argc == 0 && match != MATCH_ALL) || !(dcheck || checksums || recompute || reanalyse_shlibs)) {
usage_check();
return (EX_USAGE);
}
if (recompute || reanalyse_shlibs)
ret = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE,
PKGDB_DB_LOCAL);
else
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (ret == EPKG_ENODB) {
warnx("No packages installed. Nothing to do!");
return (EX_OK);
} else if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access the package database");
return (EX_NOPERM);
} else if (ret != EPKG_OK) {
warnx("Error accessing the package database");
return (EX_SOFTWARE);
}
ret = pkgdb_open(&db, PKGDB_DEFAULT);
if (ret != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
i = 0;
nbdone = 0;
do {
/* XXX: This is really quirky, it would be cleaner to pass
* in multiple matches and only run this top-loop once. */
if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
rc = EX_IOERR;
goto cleanup;
}
if (msg == NULL)
msg = sbuf_new_auto();
if (!verbose) {
if (match == MATCH_ALL)
progressbar_start("Checking all packages");
else {
sbuf_printf(msg, "Checking %s", argv[i]);
sbuf_finish(msg);
progressbar_start(sbuf_data(msg));
}
processed = 0;
total = pkgdb_it_count(it);
} else {
if (match == MATCH_ALL)
nbactions = pkgdb_it_count(it);
else
nbactions = argc;
}
while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
if (!verbose)
progressbar_tick(processed, total);
else {
++nbdone;
job_status_begin(msg);
pkg_sbuf_printf(msg, "Checking %n-%v:",
pkg, pkg);
sbuf_flush(msg);
}
/* check for missing dependencies */
if (dcheck) {
if (verbose)
printf(" dependencies...");
nbpkgs += check_deps(db, pkg, &dh, noinstall);
if (noinstall && nbpkgs > 0) {
rc = EX_UNAVAILABLE;
}
}
if (checksums) {
if (verbose)
printf(" checksums...");
if (pkg_test_filesum(pkg) != EPKG_OK) {
rc = EX_DATAERR;
}
}
if (recompute) {
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
if (verbose)
printf(" recomputing...");
if (pkg_recompute(db, pkg) != EPKG_OK) {
rc = EX_DATAERR;
}
pkgdb_downgrade_lock(db,
PKGDB_LOCK_EXCLUSIVE,
PKGDB_LOCK_ADVISORY);
}
else {
rc = EX_TEMPFAIL;
}
}
if (reanalyse_shlibs) {
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
if (verbose)
printf(" shared libraries...");
if (pkgdb_reanalyse_shlibs(db, pkg) != EPKG_OK) {
pkg_fprintf(stderr, "Failed to "
"reanalyse for shlibs: "
"%n-%v\n", pkg, pkg);
rc = EX_UNAVAILABLE;
}
pkgdb_downgrade_lock(db,
PKGDB_LOCK_EXCLUSIVE,
PKGDB_LOCK_ADVISORY);
}
else {
rc = EX_TEMPFAIL;
}
}
if (!verbose)
++processed;
else
printf(" done\n");
}
if (!verbose)
progressbar_tick(processed, total);
if (msg != NULL) {
sbuf_delete(msg);
msg = NULL;
}
if (dcheck && nbpkgs > 0 && !noinstall) {
printf("\n>>> Missing package dependencies were detected.\n");
printf(">>> Found %d issue(s) in the package database.\n\n", nbpkgs);
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
ret = fix_deps(db, &dh, nbpkgs, yes);
if (ret == EPKG_OK)
check_summary(db, &dh);
else if (ret == EPKG_ENODB) {
db = NULL;
rc = EX_IOERR;
}
pkgdb_downgrade_lock(db, PKGDB_LOCK_EXCLUSIVE,
PKGDB_LOCK_ADVISORY);
if (rc == EX_IOERR)
goto cleanup;
}
else {
rc = EX_TEMPFAIL;
goto cleanup;
}
}
pkgdb_it_free(it);
i++;
} while (i < argc);
cleanup:
if (!verbose)
progressbar_stop();
if (msg != NULL)
sbuf_delete(msg);
deps_free(&dh);
pkg_free(pkg);
pkgdb_release_lock(db, PKGDB_LOCK_ADVISORY);
pkgdb_close(db);
return (rc);
}
