int do_calculate_dr(const char *filename) {
struct stream_context sc;
struct dr_meter meter;
int err;
meter_init(&meter);
err = sc_open(&sc, filename);
if (err < 0) { return print_av_error("sc_open", err); }
int stream_index = err = av_find_best_stream(
sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; }
err = sc_start_stream(&sc, stream_index);
if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; }
// Print out the stream info
AVCodecContext *codec_ctx = sc_get_codec(&sc);
char codecinfobuf[256];
avcodec_string(codecinfobuf, sizeof(codecinfobuf), codec_ctx, 0);
fprintf(stderr, "%.256s\n", codecinfobuf);
err = meter_start(&meter, codec_ctx->channels, codec_ctx->sample_rate, codec_ctx->sample_fmt);
if (err) { goto cleanup; }
fprintf(stderr, "Collecting fragments information...\n");
size_t fragment = 0;
int throbbler_stage = 0;
while (!sc_eof(&sc)) {
err = sc_get_next_frame(&sc);
if (err < 0) {
print_av_error("sc_get_next_frame", err);
goto cleanup;
}
err = meter_feed(&meter, sc.buf, sc.buf_size);
if (err) { goto cleanup; }
if (fragment < meter.fragment) {
fragment = meter.fragment;
if ((throbbler_stage % 4) == 0) {
fprintf(stderr, "\033[1K\033[1G %c %2i:%02i ",
throbbler[throbbler_stage / 4],
(fragment * 3) / 60,
(fragment * 3) % 60);
}
throbbler_stage += 1;
throbbler_stage %= 16;
}
}
meter_finish(&meter);
cleanup:
meter_free(&meter);
sc_close(&sc);
if (err < 0) {
return err;
}
return 0;
}
int calculate_track_dr(const char *filename, struct track_info *t, int number) {
struct stream_context sc;
struct dr_meter meter;
int err;
meter_init(&meter);
err = sc_open(&sc, filename);
if (err < 0) { return print_av_error("sc_open", err); }
if (debug) {
printf("DEBUG: Codec: %s\n", avcodec_get_name(sc_get_codec_id(&sc)));
}
int stream_index = err = av_find_best_stream(
sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; }
err = sc_start_stream(&sc, stream_index);
if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; }
t->artist = strdup(sc_get_metadata(&sc, "artist"));
t->album = strdup(sc_get_metadata(&sc, "album"));
t->tracknumber = strdup(sc_get_metadata(&sc, "track"));
t->title = strdup(sc_get_metadata(&sc, "title"));
AVCodecParameters *codecpar = sc_get_codec_parameters(&sc);
err = meter_start(&meter, codecpar->channels, codecpar->sample_rate, codecpar->format);
if (err) { goto cleanup; }
size_t fragment = 0;
int throbbler_stage = 0;
while (!sc_eof(&sc)) {
err = sc_get_next_frame(&sc);
if (err < 0) {
print_av_error("sc_get_next_frame", err);
goto cleanup;
}
err = meter_feed(&meter, sc_get_buf(&sc), sc_get_samples(&sc));
if (err) { goto cleanup; }
if (fragment < meter.fragment) {
fragment = meter.fragment;
if ((throbbler_stage % 4) == 0) {
fprintf(stderr, "\033[1K\033[1G"
"Analyzing track %i... "
"%c %2zu:%02zu ",
number,
throbbler[throbbler_stage / 4],
(fragment * 3) / 60,
(fragment * 3) % 60);
}
throbbler_stage += 1;
throbbler_stage %= 16;
}
}
fprintf(stderr, "\033[1K\033[1G");
meter_finish(&meter, t);
cleanup:
meter_free(&meter);
sc_close(&sc);
if (err < 0) {
return err;
}
return 0;
}
int main (int argc, char* argv[])
{ /* --- main function */
int i, k = 0; /* loop variables, buffer */
char *s; /* to traverse options */
char **optarg = NULL; /* option argument */
char *fn_bc = NULL; /* name of classifier file */
char *fn_out = NULL; /* name of output file */
char *blank = NULL; /* blank */
char *fldsep = NULL; /* field separator */
char *recsep = NULL; /* record separator */
int flags = AS_ATT; /* table file write flags */
double lcorr = -DBL_MAX; /* Laplace correction value */
int dwnull = 0; /* distribute weight of null values */
int maxllh = 0; /* max. likelihood est. of variance */
int tplcnt = 1000; /* number of tuples to generate */
long seed; /* seed for random number generator */
int mode; /* classifier setup mode */
prgname = argv[0]; /* get program name for error msgs. */
seed = (long)time(NULL); /* and get a default seed value */
/* --- print startup/usage message --- */
if (argc > 1) { /* if arguments are given */
fprintf(stderr, "%s - %s\n", argv[0], DESCRIPTION);
fprintf(stderr, VERSION); } /* print a startup message */
else { /* if no argument given */
printf("usage: %s [options] bcfile "
"[-d|-h hdrfile] tabfile\n", argv[0]);
printf("%s\n", DESCRIPTION);
printf("%s\n", VERSION);
printf("-n# number of tuples to generate "
"(default: %d)\n", tplcnt);
printf("-s# seed for random number generator "
"(default: time)\n");
printf("-L# Laplace correction "
"(default: as specified in classifier)\n");
printf("-v/V (do not) distribute tuple weight "
"for null values\n");
printf("-m/M (do not) use maximum likelihood estimate "
"for the variance\n");
printf("-a align fields (default: do not align)\n");
printf("-w do not write field names to the output file\n");
printf("-b/f/r# blank character, field and record separator\n"
" (default: \" \", \" \", \"\\n\")\n");
printf("bcfile file containing classifier description\n");
printf("tabfile table file to write\n");
return 0; /* print a usage message */
} /* and abort the program */
/* --- evaluate arguments --- */
for (i = 1; i < argc; i++) { /* traverse arguments */
s = argv[i]; /* get option argument */
if (optarg) { *optarg = s; optarg = NULL; continue; }
if ((*s == '-') && *++s) { /* -- if argument is an option */
while (*s) { /* traverse options */
switch (*s++) { /* evaluate option */
case 'n': tplcnt = (int)strtol(s, &s, 0); break;
case 's': seed = strtol(s, &s, 0); break;
case 'L': lcorr = strtod(s, &s); break;
case 'v': dwnull = NBC_ALL; break;
case 'V': dwnull |= NBC_DWNULL|NBC_ALL; break;
case 'm': maxllh = NBC_ALL; break;
case 'M': maxllh |= NBC_MAXLLH|NBC_ALL; break;
case 'a': flags |= AS_ALIGN; break;
case 'w': flags &= ~AS_ATT; break;
case 'b': optarg = ␣ break;
case 'f': optarg = &fldsep; break;
case 'r': optarg = &recsep; break;
default : error(E_OPTION, *--s); break;
} /* set option variables */
if (!*s) break; /* if at end of string, abort loop */
if (optarg) { *optarg = s; optarg = NULL; break; }
} } /* get option argument */
else { /* if argument is no option */
switch (k++) { /* evaluate non-option */
case 0: fn_bc = s; break;
case 1: fn_out = s; break;
default: error(E_ARGCNT); break;
} /* note filenames */
}
}
if (optarg) error(E_OPTARG); /* check the option argument */
if (k != 2) error(E_ARGCNT); /* and the number of arguments */
if ((lcorr < 0) && (lcorr > -DBL_MAX))
error(E_NEGLC); /* check the Laplace correction */
if ((flags & AS_ATT) && (flags & AS_ALIGN))
flags |= AS_ALNHDR; /* set align to header flag */
/* --- read Bayes classifier --- */
scan = sc_create(fn_bc); /* create a scanner */
if (!scan) error((!fn_bc || !*fn_bc) ? E_NOMEM : E_FOPEN, fn_bc);
attset = as_create("domains", att_delete);
if (!attset) error(E_NOMEM); /* create an attribute set */
fprintf(stderr, "\nreading %s ... ", sc_fname(scan));
if ((sc_nexter(scan) < 0) /* start scanning (get first token) */
|| (as_parse(attset, scan, AT_ALL) != 0)
|| (as_attcnt(attset) <= 0)) /* parse attribute set */
error(E_PARSE, sc_fname(scan));
if ((sc_token(scan) == T_ID) /* determine classifier type */
&& (strcmp(sc_value(scan), "fbc") == 0))
fbc = fbc_parse(attset, scan);
else nbc = nbc_parse(attset, scan);
if ((!fbc && !nbc) /* parse the Bayes classifier */
|| !sc_eof(scan)) /* and check for end of file */
error(E_PARSE, sc_fname(scan));
sc_delete(scan); scan = NULL; /* delete the scanner */
fprintf(stderr, "[%d attribute(s)] done.\n", as_attcnt(attset));
if ((lcorr >= 0) || dwnull || maxllh) {
if (lcorr < 0) /* get the classifier's parameters */
lcorr = (fbc) ? fbc_lcorr(fbc) : nbc_lcorr(nbc);
mode = (fbc) ? fbc_mode(fbc) : nbc_mode(nbc);
if (dwnull) mode = (mode & ~NBC_DWNULL) | dwnull;
if (maxllh) mode = (mode & ~NBC_MAXLLH) | maxllh;
/* adapt the estimation parameters */
if (fbc) fbc_setup(fbc, mode, lcorr);
else nbc_setup(nbc, mode, lcorr);
} /* set up the classifier anew */
/* --- generate database --- */
if (fn_out && *fn_out) /* if an output file name is given, */
out = fopen(fn_out, "w"); /* open output file for writing */
else { /* if no output file name is given, */
out = stdout; fn_out = "<stdout>"; } /* write to std. output */
fprintf(stderr, "writing %s ... ", fn_out);
if (!out) error(E_FOPEN, fn_out);
if ((flags & AS_ATT) /* if to write a table header */
&& (as_write(attset, out, flags) != 0))
error(E_FWRITE, fn_out); /* write the attributes names */
flags = AS_INST | (flags & ~AS_ATT);
dseed(seed); /* init. random number generator */
for (i = tplcnt; --i >= 0;) { /* generate random tuples */
if (fbc) fbc_rand(fbc, drand); /* instantiate the */
else nbc_rand(nbc, drand); /* attribute set */
if (as_write(attset, out, flags) != 0)
error(E_FWRITE,fn_out); /* write the generated tuple */
} /* to the output file */
if (out != stdout) { /* if not written to stdout */
i = fclose(out); out = NULL;/* close the output file */
if (i != 0) error(E_FWRITE, fn_out);
} /* print a success message */
fprintf(stderr, "[%d tuple(s)] done.\n", tplcnt);
/* --- clean up --- */
#ifndef NDEBUG
if (fbc) fbc_delete(fbc, 1); /* delete full Bayes classifier */
if (nbc) nbc_delete(nbc, 1); /* or naive Bayes classifier */
#endif /* and underlying attribute set */
#ifdef STORAGE
showmem("at end of program"); /* check memory usage */
#endif
return 0; /* return 'ok' */
} /* main() */
