int main(int argc, char **argv) {
char *commandline;
int errorcode, ret1, ret2, ret3;
commandline = process_commandline(argc, argv);
/*open camera interface*/
VISCA_open_interface(&interface, &camera, ttydev);
errorcode = VISCA_doCommand(commandline, &ret1, &ret2, &ret3, &interface, &camera);
switch(errorcode) {
case 10:
printf("10 OK - no return value\n");
break;
case 11:
printf("11 OK - one return value\nRET1: %i\n", ret1);
break;
case 12:
printf("12 OK - two return values\nRET1: %i\nRET2: %i\n", ret1, ret2);
break;
case 13:
printf("13 OK - three return values\nRET1: %i\nRET2: %i\nRET3: %i\n",
ret1, ret2, ret3);
break;
case 40:
printf("40 ERROR - command not recognized\n");
break;
case 41:
printf("41 ERROR - argument 1 not recognized\n");
break;
case 42:
printf("42 ERROR - argument 2 not recognized\n");
break;
case 43:
printf("43 ERROR - argument 3 not recognized\n");
break;
case 44:
printf("44 ERROR - argument 4 not recognized\n");
break;
case 45:
printf("45 ERROR - argument 5 not recognized\n");
break;
case 46:
printf("46 ERROR - camera replied with an error\n");
break;
case 47:
printf("47 ERROR - camera replied with an unknown return value\n");
break;
default:
printf("unknown error code: %i\n", errorcode);
}
VISCA_close_interface(&interface);
exit(0);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL;
struct cfg_s cfg;
int status = eslOK;
impl_Init(); /* processor specific initialization */
p7_FLogsumInit(); /* we're going to use table-driven Logsum() approximations at times */
/* Initialize what we can in the config structure (without knowing the alphabet yet)
*/
cfg.hmmfile = NULL;
cfg.dbfile = NULL;
cfg.do_mpi = FALSE; /* this gets reset below, if we init MPI */
cfg.nproc = 0; /* this gets reset below, if we init MPI */
cfg.my_rank = 0; /* this gets reset below, if we init MPI */
cfg.firstseq_key = NULL;
cfg.n_targetseq = -1;
process_commandline(argc, argv, &go, &cfg.hmmfile, &cfg.dbfile);
/* is the range restricted? */
if (esl_opt_IsUsed(go, "--restrictdb_stkey") )
if ((cfg.firstseq_key = esl_opt_GetString(go, "--restrictdb_stkey")) == NULL) p7_Fail("Failure capturing --restrictdb_stkey\n");
if (esl_opt_IsUsed(go, "--restrictdb_n") )
cfg.n_targetseq = esl_opt_GetInteger(go, "--restrictdb_n");
if ( cfg.n_targetseq != -1 && cfg.n_targetseq < 1 )
p7_Fail("--restrictdb_n must be >= 1\n");
{
status = serial_master(go, &cfg);
}
esl_getopts_Destroy(go);
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL;
struct cfg_s cfg;
int status = eslOK;
impl_Init(); /* processor-specific initialization */
p7_FLogsumInit(); /* we're going to use table-driven Logsum() approximations at times */
/* Initialize what we can in the config structure (without knowing the alphabet yet) */
cfg.hmmfile = NULL;
cfg.seqfile = NULL;
cfg.do_mpi = FALSE; /* this gets reset below, if we init MPI */
cfg.nproc = 0; /* this gets reset below, if we init MPI */
cfg.my_rank = 0; /* this gets reset below, if we init MPI */
process_commandline(argc, argv, &go, &cfg.hmmfile, &cfg.seqfile);
status = serial_master(go, &cfg);
esl_getopts_Destroy(go);
return status;
}
int
main(int argc, char *argv[])
{
serverstate_set_event_loop(uv_default_loop());
config_init();
listener_init();
client_init();
module_init();
server_init();
command_init();
connection_init();
process_commandline(argv, argc);
config_load();
listener_start_listeners();
module_load_all_modules();
connection_init_tls();
uv_run(serverstate_get_event_loop(), UV_RUN_DEFAULT);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_STOPWATCH *w = esl_stopwatch_Create();
struct cfg_s cfg;
/* Set processor specific flags */
impl_Init();
cfg.alifile = NULL;
cfg.hmmfile = NULL;
/* Parse the command line
*/
process_commandline(argc, argv, &go, &cfg.hmmfile, &cfg.alifile);
/* Initialize what we can in the config structure (without knowing the alphabet yet)
*/
cfg.ofp = NULL; /* opened in init_master_cfg() */
cfg.fmt = eslMSAFILE_UNKNOWN; /* autodetect alignment format by default. */
cfg.afp = NULL; /* created in init_master_cfg() */
cfg.abc = NULL; /* created in init_master_cfg() in masters, or in mpi_worker() in workers */
cfg.hmmfp = NULL; /* opened in init_master_cfg() */
cfg.postmsafile = esl_opt_GetString(go, "-O"); /* NULL by default */
cfg.postmsafp = NULL; /* opened in init_master_cfg() */
cfg.nali = 0; /* this counter is incremented in masters */
cfg.nnamed = 0; /* 0 or 1 if a single MSA; == nali if multiple MSAs */
cfg.do_mpi = FALSE; /* this gets reset below, if we init MPI */
cfg.nproc = 0; /* this gets reset below, if we init MPI */
cfg.my_rank = 0; /* this gets reset below, if we init MPI */
cfg.do_stall = esl_opt_GetBoolean(go, "--stall");
cfg.hmmName = esl_opt_GetString(go, "-n"); /* NULL by default */
if (esl_opt_IsOn(go, "--informat")) {
cfg.fmt = esl_msa_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (cfg.fmt == eslMSAFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--informat"));
}
/* This is our stall point, if we need to wait until we get a
* debugger attached to this process for debugging (especially
* useful for MPI):
*/
while (cfg.do_stall);
/* Start timing. */
esl_stopwatch_Start(w);
/* Figure out who we are, and send control there:
* we might be an MPI master, an MPI worker, or a serial program.
*/
#ifdef HAVE_MPI
if (esl_opt_GetBoolean(go, "--mpi"))
{
cfg.do_mpi = TRUE;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &(cfg.my_rank));
MPI_Comm_size(MPI_COMM_WORLD, &(cfg.nproc));
if (cfg.my_rank > 0) mpi_worker(go, &cfg);
else mpi_master(go, &cfg);
esl_stopwatch_Stop(w);
esl_stopwatch_MPIReduce(w, 0, MPI_COMM_WORLD);
MPI_Finalize();
}
else
#endif /*HAVE_MPI*/
{
serial_master(go, &cfg);
esl_stopwatch_Stop(w);
}
if (cfg.my_rank == 0) {
fputc('\n', cfg.ofp);
esl_stopwatch_Display(cfg.ofp, w, "# CPU time: ");
}
/* Clean up the shared cfg.
*/
if (cfg.my_rank == 0) {
if (esl_opt_IsOn(go, "-o")) { fclose(cfg.ofp); }
if (cfg.afp != NULL) esl_msafile_Close(cfg.afp);
if (cfg.abc != NULL) esl_alphabet_Destroy(cfg.abc);
if (cfg.hmmfp != NULL) fclose(cfg.hmmfp);
}
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
}
int process_commandline(int argc, char **argv, SMSD_Parameters * params)
{
int opt;
#ifdef HAVE_GETOPT_LONG
struct option long_options[] = {
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{"config", 1, 0, 'c'},
{"use-log", 0, 0, 'l'},
{"no-use-log", 0, 0, 'L'},
{0, 0, 0, 0}
};
int option_index;
while ((opt =
getopt_long(argc, argv, "+hvc:lL", long_options,
&option_index)) != -1) {
#elif defined(HAVE_GETOPT)
while ((opt = getopt(argc, argv, "+hvc:lL")) != -1) {
#else
/* Poor mans getopt replacement */
int i;
#define optarg argv[++i]
for (i = 1; i < argc; i++) {
if (strlen(argv[i]) != 2 || argv[i][0] != '-') {
return i;
}
opt = argv[i][1];
#endif
switch (opt) {
case 'c':
params->config_file = optarg;
break;
case 'v':
version();
break;
case 'l':
params->use_log = TRUE;
break;
case 'L':
params->use_log = FALSE;
break;
case '?':
wrong_params();
case 'h':
help();
exit(0);
default:
fprintf(stderr, "Parameter -%c not known!\n", opt);
wrong_params();
break;
}
}
#if defined(HAVE_GETOPT_LONG) || defined(HAVE_GETOPT)
return optind;
#else
return i;
#endif
}
#ifndef WIN32
#endif
int main(int argc, char **argv)
{
GSM_Error error;
int startarg;
GSM_MultiSMSMessage sms;
GSM_Message_Type type = SMS_SMSD;
GSM_SMSDConfig *config;
const char program_name[] = "gammu-smsd-inject";
char newid[200] = { 0 };
SMSD_Parameters params = {
NULL,
NULL,
-1,
-1,
NULL,
NULL,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
0
};
/*
* We don't need gettext, but need to set locales so that
* charset conversion works.
*/
GSM_InitLocales(NULL);
startarg = process_commandline(argc, argv, ¶ms);
if (params.config_file == NULL) {
#ifdef HAVE_DEFAULT_CONFIG
params.config_file = default_config;
#else
fprintf(stderr, "No config file specified!\n");
help();
exit(1);
#endif
}
error = CreateMessage(&type, &sms, argc, startarg, argv, NULL);
if (error != ERR_NONE) {
printf("Failed to create message: %s\n",
GSM_ErrorString(error));
return 1;
}
config = SMSD_NewConfig(program_name);
assert(config != NULL);
error = SMSD_ReadConfig(params.config_file, config, params.use_log);
if (error != ERR_NONE) {
printf("Failed to read config: %s\n", GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 2;
}
SMSD_EnableGlobalDebug(config);
error = SMSD_InjectSMS(config, &sms, newid);
if (error != ERR_NONE) {
printf("Failed to inject message: %s\n",
GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 3;
}
if (strlen(newid) == 0) {
printf("Written message without ID\n");
} else {
printf("Written message with ID %s\n", newid);
}
SMSD_FreeConfig(config);
return 0;
}
/* Function: main()
* Synopsis: Run set of queries against an FM
* Purpose: Read in a FM and a file of query sequences.
* For each query, find matching FM interval, then collect positions in
* the original text T for the corresponding occurrences. These positions
* are 0-based (so first character is position 0).
*/
int
main(int argc, char *argv[])
{
void* tmp; // used for RALLOC calls
clock_t t1, t2;
struct tms ts1, ts2;
char *fname_fm = NULL;
char *fname_queries = NULL;
FM_HIT *hits = NULL;
char *line = NULL;
int status = eslOK;
int hit_cnt = 0;
int hit_indiv_cnt = 0;
int miss_cnt = 0;
int hit_num = 0;
int hit_num2 = 0;
int hits_size = 0;
int i,j;
int count_only = 0;
FM_INTERVAL interval;
FM_DATA *fmsf = NULL;
FM_DATA *fmsb = NULL;
FILE* fp_fm = NULL;
FILE* fp = NULL;
FILE* out = NULL;
char *outname = NULL;
ESL_GETOPTS *go = NULL; /* command line processing */
FM_CFG *cfg;
FM_METADATA *meta;
ESL_SQ *tmpseq; // used for sequence validation
ESL_ALPHABET *abc = NULL;
//start timer
t1 = times(&ts1);
process_commandline(argc, argv, &go, &fname_fm, &fname_queries);
if (esl_opt_IsOn(go, "--out")) {
outname = esl_opt_GetString(go, "--out");
if ( esl_strcmp ("-", outname) == 0 ) {
out = stdout;
outname = "stdout";
} else {
out = fopen(outname,"w");
}
}
if (esl_opt_IsOn(go, "--count_only"))
count_only = 1;
if((fp_fm = fopen(fname_fm, "rb")) == NULL)
esl_fatal("Cannot open file `%s': ", fname_fm);
fm_configAlloc(&cfg);
cfg->occCallCnt = 0;
meta = cfg->meta;
meta->fp = fp_fm;
fm_readFMmeta( meta);
if (meta->alph_type == fm_DNA) abc = esl_alphabet_Create(eslDNA);
else if (meta->alph_type == fm_AMINO) abc = esl_alphabet_Create(eslAMINO);
tmpseq = esl_sq_CreateDigital(abc);
//read in FM-index blocks
ESL_ALLOC(fmsf, meta->block_count * sizeof(FM_DATA) );
if (!meta->fwd_only)
ESL_ALLOC(fmsb, meta->block_count * sizeof(FM_DATA) );
for (i=0; i<meta->block_count; i++) {
fm_FM_read( fmsf+i,meta, TRUE );
if (!meta->fwd_only) {
fm_FM_read(fmsb+i, meta, FALSE );
fmsb[i].SA = fmsf[i].SA;
fmsb[i].T = fmsf[i].T;
}
}
fclose(fp_fm);
output_header(meta, stdout, go, fname_fm, fname_queries);
/* initialize a few global variables, then call initGlobals
* to do architecture-specific initialization
*/
fm_configInit(cfg, NULL);
fm_alphabetCreate(meta, NULL); // don't override charBits
fp = fopen(fname_queries,"r");
if (fp == NULL)
esl_fatal("Unable to open file %s\n", fname_queries);
ESL_ALLOC(line, FM_MAX_LINE * sizeof(char));
hits_size = 200;
ESL_ALLOC(hits, hits_size * sizeof(FM_HIT));
while(fgets(line, FM_MAX_LINE, fp) ) {
int qlen=0;
while (line[qlen] != '\0' && line[qlen] != '\n') qlen++;
if (line[qlen] == '\n') line[qlen] = '\0';
hit_num = 0;
for (i=0; i<meta->block_count; i++) {
fm_getSARangeReverse(fmsf+i, cfg, line, meta->inv_alph, &interval);
if (interval.lower>=0 && interval.lower <= interval.upper) {
int new_hit_num = interval.upper - interval.lower + 1;
hit_num += new_hit_num;
if (!count_only) {
if (hit_num > hits_size) {
hits_size = 2*hit_num;
ESL_RALLOC(hits, tmp, hits_size * sizeof(FM_HIT));
}
getFMHits(fmsf+i, cfg, &interval, i, hit_num-new_hit_num, qlen, hits, fm_forward);
}
}
/* find reverse hits, using backward search on the forward FM*/
if (!meta->fwd_only) {
fm_getSARangeForward(fmsb+i, cfg, line, meta->inv_alph, &interval);// yes, use the backward fm to produce the equivalent of a forward search on the forward fm
if (interval.lower>=0 && interval.lower <= interval.upper) {
int new_hit_num = interval.upper - interval.lower + 1;
hit_num += new_hit_num;
if (!count_only) {
if (hit_num > hits_size) {
hits_size = 2*hit_num;
ESL_RALLOC(hits, tmp, hits_size * sizeof(FM_HIT));
}
//even though I used fmsb above, use fmsf here, since we'll now do a backward trace
//in the FM-index to find the next sampled SA position
getFMHits(fmsf+i, cfg, &interval, i, hit_num-new_hit_num, qlen, hits, fm_backward);
}
}
}
}
if (hit_num > 0) {
if (count_only) {
hit_cnt++;
hit_indiv_cnt += hit_num;
} else {
hit_num2 = 0;
//for each hit, identify the sequence id and position within that sequence
for (i = 0; i< hit_num; i++) {
status = fm_getOriginalPosition (fmsf, meta, hits[i].block, hits[i].length, fm_forward, hits[i].start, &(hits[i].block), &(hits[i].start) );
hits[i].sortkey = (status==eslERANGE ? -1 : meta->seq_data[ hits[i].block ].target_id);
//validate match - if any characters in orig sequence were ambiguities, reject
fm_convertRange2DSQ( fmsf, meta, hits[i].start, hits[i].length, p7_NOCOMPLEMENT, tmpseq, TRUE );
for (j=1; j<=hits[i].length; j++) {
if (tmpseq->dsq[j] >= abc->K) {
hits[i].sortkey = -1; //reject
j = hits[i].length+1; //quit looking
}
}
if (hits[i].sortkey != -1)
hit_num2++; // legitimate hit
}
if (hit_num2 > 0)
hit_cnt++;
//now sort according the the sequence_id corresponding to that seq_offset
qsort(hits, hit_num, sizeof(FM_HIT), hit_sorter);
//skim past the skipped entries
i = 0;
while ( i < hit_num ) {
if (hits[i].sortkey != -1 )
break; //
i++;
}
if (i < hit_num) {
if (out != NULL) {
fprintf (out, "%s\n",line);
//fprintf (out, "\t%10s (%8d %s)\n",meta->seq_data[ hits[i].block ].name, hits[i].start, (hits[i].direction==fm_forward?"+":"-"));
fprintf (out, " %8ld %s %10s\n", (long)(hits[i].start), (hits[i].direction==fm_forward?"f":"r"), meta->seq_data[ hits[i].block ].name);
}
hit_indiv_cnt++;
i++; // skip the first one, since I'll be comparing each to the previous
for ( ; i< hit_num; i++) {
if ( //meta->seq_data[ hits[i].block ].id != meta->seq_data[ hits[i-1].block ].id ||
hits[i].sortkey != hits[i-1].sortkey || //sortkey is seq_data[].id
hits[i].direction != hits[i-1].direction ||
hits[i].start != hits[i-1].start )
{
if (out != NULL)
//fprintf (out, "\t%10s (%8d %s)\n",meta->seq_data[ hits[i].block ].name, hits[i].start, (hits[i].direction==fm_forward?"+":"-"));
fprintf (out, " %8ld %s %10s\n", (long)(hits[i].start), (hits[i].direction==fm_forward?"f":"r"), meta->seq_data[ hits[i].block ].name);
hit_indiv_cnt++;
}
}
if (out != NULL)
fprintf (out, "\n");
}
}
} else {
miss_cnt++;
}
}
for (i=0; i<meta->block_count; i++) {
fm_FM_destroy( fmsf+i, 1 );
if (!meta->fwd_only)
fm_FM_destroy( fmsb+i, 0 );
}
free (hits);
free (line);
fclose(fp);
fm_configDestroy(cfg);
// compute and print the elapsed time in millisec
t2 = times(&ts2);
{
double clk_ticks = sysconf(_SC_CLK_TCK);
double elapsedTime = (t2-t1)/clk_ticks;
double throughput = cfg->occCallCnt/elapsedTime;
fprintf (stderr, "hit: %-10d (%d)\n", hit_cnt, hit_indiv_cnt);
fprintf (stderr, "miss:%-10d\n", miss_cnt);
fprintf (stderr, "run time: %.2f seconds\n", elapsedTime);
fprintf (stderr, "occ calls: %12s\n", commaprint(cfg->occCallCnt));
fprintf (stderr, "occ/sec: %12s\n", commaprint(throughput));
}
exit(eslOK);
ERROR:
printf ("failure allocating memory for hits\n");
exit(status);
}
int
main(int argc, char **argv)
{
int i,j;
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_STOPWATCH *w = esl_stopwatch_Create();
int status;
ESL_MSA *msa = NULL;
FILE *ofp = NULL; /* output file (default is stdout) */
ESL_ALPHABET *abc = NULL; /* digital alphabet */
char *alifile; /* name of the alignment file we're building HMMs from */
ESLX_MSAFILE *afp = NULL; /* open alifile */
int infmt = eslMSAFILE_UNKNOWN; /* autodetect alignment format by default. */
int outfmt = eslMSAFILE_STOCKHOLM;
char *postmsafile; /* optional file to resave annotated, modified MSAs to */
FILE *postmsafp = NULL; /* open <postmsafile>, or NULL */
int mask_range_cnt = 0;
uint32_t mask_starts[100]; // over-the-top allocation.
uint32_t mask_ends[100];
char *rangestr;
char *range;
int *map = NULL; /* map[i]=j, means model position i comes from column j of the alignment; 1..alen */
int keep_mm;
/* Set processor specific flags */
impl_Init();
alifile = NULL;
postmsafile = NULL;
/* Parse the command line
*/
process_commandline(argc, argv, &go, &alifile, &postmsafile);
keep_mm = esl_opt_IsUsed(go, "--apendmask");
/* Initialize what we can in the config structure (without knowing the alphabet yet).
* Fields controlled by masters are set up in usual_master() or mpi_master()
* Fields used by workers are set up in mpi_worker()
*/
ofp = NULL;
infmt = eslMSAFILE_UNKNOWN;
afp = NULL;
abc = NULL;
if (esl_opt_IsOn(go, "--informat")) {
infmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (infmt == eslMSAFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--informat"));
}
/* Determine output alignment file format */
outfmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--outformat"));
if (outfmt == eslMSAFILE_UNKNOWN) p7_Fail(argv[0], "%s is not a recognized output MSA file format\n", esl_opt_GetString(go, "--outformat"));
/* Parse the ranges */
if (esl_opt_IsUsed(go, "--alirange")) {
esl_strdup(esl_opt_GetString(go, "--alirange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--modelrange")) {
esl_strdup(esl_opt_GetString(go, "--modelrange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--model2ali")) {
esl_strdup(esl_opt_GetString(go, "--model2ali"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--ali2model")) {
esl_strdup(esl_opt_GetString(go, "--ali2model"), -1, &rangestr) ;
} else {
if (puts("Must specify mask range with --modelrange, --alirange, --model2ali, or --ali2model\n") < 0) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed"); goto ERROR;
}
while ( (status = esl_strtok(&rangestr, ",", &range) ) == eslOK) {
status = esl_regexp_ParseCoordString(range, mask_starts + mask_range_cnt, mask_ends + mask_range_cnt );
if (status == eslESYNTAX) esl_fatal("range flags take coords <from>..<to>; %s not recognized", range);
if (status == eslFAIL) esl_fatal("Failed to find <from> or <to> coord in %s", range);
mask_range_cnt++;
}
/* Start timing. */
esl_stopwatch_Start(w);
/* Open files, set alphabet.
* afp - open alignment file for input
* abc - alphabet expected or guessed in ali file
* postmsafp - open MSA output file
* ofp - optional open output file, or stdout
*/
if (esl_opt_GetBoolean(go, "--amino")) abc = esl_alphabet_Create(eslAMINO);
else if (esl_opt_GetBoolean(go, "--dna")) abc = esl_alphabet_Create(eslDNA);
else if (esl_opt_GetBoolean(go, "--rna")) abc = esl_alphabet_Create(eslRNA);
else abc = NULL;
status = eslx_msafile_Open(&abc, alifile, NULL, infmt, NULL, &afp);
if (status != eslOK) eslx_msafile_OpenFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
postmsafp = fopen(postmsafile, "w");
if (postmsafp == NULL) p7_Fail("Failed to MSA output file %s for writing", postmsafile);
}
if (esl_opt_IsUsed(go, "-o"))
{
ofp = fopen(esl_opt_GetString(go, "-o"), "w");
if (ofp == NULL) p7_Fail("Failed to open -o output file %s\n", esl_opt_GetString(go, "-o"));
}
else ofp = stdout;
/* Looks like the i/o is set up successfully...
* Initial output to the user
*/
output_header(go, ofp, alifile, postmsafile); /* cheery output header */
/* read the alignment */
if ((status = eslx_msafile_Read(afp, &msa)) != eslOK) eslx_msafile_ReadFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
/* add/modify mmline for the mask */
if (msa->mm == NULL) {
ESL_ALLOC(msa->mm, msa->alen);
keep_mm = FALSE;
}
if (!keep_mm)
for (i=0; i<msa->alen; i++) msa->mm[i] = '.';
}
// convert model coordinates to alignment coordinates, if necessary
if (esl_opt_IsUsed(go, "--modelrange") || esl_opt_IsUsed(go, "--model2ali") || esl_opt_IsUsed(go, "--ali2model") ) {
float symfrac = esl_opt_GetReal(go, "--symfrac");
int do_hand = esl_opt_IsOn(go, "--hand");
int L;
//same as p7_builder relative_weights
if (esl_opt_IsOn(go, "--wnone") ) { esl_vec_DSet(msa->wgt, msa->nseq, 1.); }
else if (esl_opt_IsOn(go, "--wgiven") ) ;
else if (esl_opt_IsOn(go, "--wpb") ) status = esl_msaweight_PB(msa);
else if (esl_opt_IsOn(go, "--wgsc") ) status = esl_msaweight_GSC(msa);
else if (esl_opt_IsOn(go, "--wblosum")) status = esl_msaweight_BLOSUM(msa, esl_opt_GetReal(go, "--wid"));
if ((status = esl_msa_MarkFragments(msa, esl_opt_GetReal(go, "--fragthresh"))) != eslOK) goto ERROR;
//build a map of model mask coordinates to alignment coords
ESL_ALLOC(map, sizeof(int) * (msa->alen+1));
L = p7_Alimask_MakeModel2AliMap(msa, do_hand, symfrac, map );
if ( esl_opt_IsUsed(go, "--model2ali") ) {
//print mapping
printf ("model coordinates alignment coordinates\n");
for (i=0; i<mask_range_cnt; i++)
printf ("%8d..%-8d -> %8d..%-8d\n", mask_starts[i], mask_ends[i], map[mask_starts[i]-1], map[mask_ends[i]-1]);
/* If I wanted to, I could print all the map values independently:
printf("\n\n-----------\n");
printf("Map\n");
printf("---\n");
for (i=0; i<L; i++)
printf("%d -> %d\n", i+1, map[i]);
*/
} else if ( esl_opt_IsUsed(go, "--ali2model") ) {
//print mapping (requires scanning the inverted map
int alistart = 0;
int aliend = 0;
printf ("alignment coordinates model coordinates\n");
for (i=0; i<mask_range_cnt; i++) {
//find j for ali positions
while (map[alistart] < mask_starts[i] )
alistart++;
aliend = alistart;
while (map[aliend] < mask_ends[i] )
aliend++;
printf (" %8d..%-8d -> %8d..%-8d\n", map[alistart], map[aliend], alistart+1, aliend+1);
}
} else {
//convert the mask coords based on map
for (i=0; i<mask_range_cnt; i++) {
mask_starts[i] = map[mask_starts[i]-1]; //-1 because mmline is offset by one relative to the 1-base alignment
mask_ends[i] = map[mask_ends[i]-1];
}
}
}
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
//overwrite '.' with 'm' everywhere the range says to do it
for (i=0; i<mask_range_cnt; i++)
for (j=mask_starts[i]; j<=mask_ends[i]; j++)
msa->mm[j-1] = 'm';
if ((status = eslx_msafile_Write(postmsafp, msa, outfmt)) != eslOK) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed");
}
esl_stopwatch_Stop(w);
if (esl_opt_IsOn(go, "-o")) fclose(ofp);
if (postmsafp) fclose(postmsafp);
if (afp) eslx_msafile_Close(afp);
if (abc) esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
ERROR:
return eslFAIL;
}
void process_commandline(int argc, char **argv, SMSD_Parameters * params)
{
int opt;
#ifdef HAVE_GETOPT_LONG
struct option long_options[] = {
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{"config", 1, 0, 'c'},
{"daemon", 0, 0, 'd'},
{"pid", 1, 0, 'p'},
{"install-service", 0, 0, 'i'},
{"uninstall-service", 0, 0, 'u'},
{"start-service", 0, 0, 's'},
{"stop-service", 0, 0, 'k'},
{"run-as-service", 0, 0, 'S'},
{"user", 1, 0, 'U'},
{"group", 1, 0, 'G'},
{"service-name", 1, 0, 'n'},
{"suicide", 1, 0, 'X'},
{"max-failures", 1, 0, 'f'},
{"use-log", 0, 0, 'l'},
{"no-use-log", 0, 0, 'L'},
{"install-event-log", 0, 0, 'e'},
{"uninstall-event-log", 0, 0, 'E'},
{0, 0, 0, 0}
};
int option_index;
while ((opt = getopt_long(argc, argv, "hvdc:p:iusSkU:G:n:X:f:lLeE", long_options, &option_index)) != -1) {
#elif defined(HAVE_GETOPT)
while ((opt = getopt(argc, argv, "hvdc:p:iusSkU:G:n:X:f:lLeE")) != -1) {
#else
/* Poor mans getopt replacement */
int i;
#define optarg argv[++i]
for (i = 1; i < argc; i++) {
if (strlen(argv[i]) != 2 || argv[i][0] != '-') {
wrong_params();
}
opt = argv[i][1];
#endif
switch (opt) {
case 'c':
params->config_file = optarg;
break;
#ifdef HAVE_PIDFILE
case 'p':
params->pid_file = optarg;
break;
#endif
#ifdef HAVE_UID
case 'U':
if (!fill_uid(params, optarg)) {
fprintf(stderr, "Wrong user name/ID!\n");
exit(1);
}
break;
case 'G':
if (!fill_gid(params, optarg)) {
fprintf(stderr, "Wrong group name/ID!\n");
exit(1);
}
break;
#endif
case 'f':
params->max_failures = atoi(optarg);
break;
#ifdef HAVE_ALARM
case 'X':
alarm(atoi(optarg));
break;
#endif
#ifdef HAVE_DAEMON
case 'd':
params->daemonize = TRUE;
break;
#endif
#ifdef HAVE_WINDOWS_EVENT_LOG
case 'e':
params->install_evlog = TRUE;
break;
case 'E':
params->uninstall_evlog = TRUE;
break;
#endif
#ifdef HAVE_WINDOWS_SERVICE
case 'i':
params->install_service = TRUE;
break;
case 'u':
params->uninstall_service = TRUE;
break;
case 's':
params->start_service = TRUE;
break;
case 'k':
params->stop_service = TRUE;
break;
case 'S':
params->run_service = TRUE;
break;
case 'n':
strncpy(smsd_service_name, optarg, SERVICE_NAME_LENGTH);
smsd_service_name[SERVICE_NAME_LENGTH - 1] = 0;
break;
#endif
case 'v':
version();
break;
case 'l':
params->use_log = TRUE;
break;
case 'L':
params->use_log = FALSE;
break;
case '?':
wrong_params();
case 'h':
help();
exit(0);
default:
wrong_params();
break;
}
}
#if defined(HAVE_GETOPT) || defined(HAVE_GETOPT_LONG)
if (optind < argc) {
wrong_params();
}
#endif
}
void configure_daemon(SMSD_Parameters * params)
{
signal(SIGINT, smsd_interrupt);
signal(SIGTERM, smsd_interrupt);
#ifdef HAVE_SIGHUP
signal(SIGHUP, smsd_reconfigure);
#endif
#ifdef HAVE_ALARM
signal(SIGALRM, smsd_interrupt);
#endif
#if defined(HAVE_SIGUSR1) && defined(HAVE_SIGUSR2)
signal(SIGUSR1, smsd_standby);
signal(SIGUSR2, smsd_resume);
#endif
#ifdef HAVE_DAEMON
/* Daemonize has to be before writing PID as it changes it */
if (params->daemonize) {
if (daemon(1, 0) != 0) {
fprintf(stderr, "daemonizing failed! (%s)\n", strerror(errno));
exit(1);
}
}
#endif
#ifdef HAVE_PIDFILE
/* Writing PID file has to happen before dropping privileges */
if (params->pid_file != NULL && strlen(params->pid_file) > 0) {
check_pid(params->pid_file);
write_pid(params->pid_file);
}
#endif
#ifdef HAVE_UID
if (params->gid != -1 || params->uid != -1) {
if (!set_uid_gid(params)) {
fprintf(stderr, "changing uid/gid failed! (%s)\n", strerror(errno));
exit(1);
}
}
#endif
#ifdef HAVE_WINDOWS_SERVICE
if (params->run_service) {
if (!start_smsd_service_dispatcher()) {
printf("Error starting %s service\n", smsd_service_name);
service_print_error("Error running service");
exit(1);
}
SMSD_FreeConfig(config);
exit(0);
}
#endif
}
int main(int argc, char **argv)
{
GSM_Error error;
const char program_name[] = "gammu-smsd";
SMSD_Parameters params = {
NULL,
NULL,
-1,
-1,
NULL,
NULL,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
0
};
/*
* We don't need gettext, but need to set locales so that
* charset conversion works.
*/
GSM_InitLocales(NULL);
process_commandline(argc, argv, ¶ms);
#ifdef HAVE_WINDOWS_SERVICE
if (params.stop_service) {
if (stop_smsd_service()) {
printf("Service %s stopped sucessfully\n", smsd_service_name);
exit(0);
} else {
printf("Error stopping %s service\n", smsd_service_name);
service_print_error("Error stopping service");
exit(1);
}
}
if (params.uninstall_service) {
if (uninstall_smsd_service()) {
printf("Service %s uninstalled sucessfully\n", smsd_service_name);
exit(0);
} else {
printf("Error uninstalling %s service\n", smsd_service_name);
service_print_error("Error uninstalling service");
exit(1);
}
}
#endif
#ifdef HAVE_WINDOWS_EVENT_LOG
if (params.install_evlog) {
if (eventlog_register()) {
printf("Installed event log description\n");
exit(0);
} else {
printf("Failed to install event log description!\n");
exit(1);
}
}
if (params.uninstall_evlog) {
if (eventlog_deregister()) {
printf("Uninstalled event log description\n");
exit(0);
} else {
printf("Failed to uninstall event log description!\n");
exit(1);
}
}
#endif
if (params.config_file == NULL) {
#ifdef HAVE_DEFAULT_CONFIG
params.config_file = default_config;
#else
fprintf(stderr, "No config file specified!\n");
help();
exit(1);
#endif
}
#ifdef HAVE_WINDOWS_SERVICE
if (params.install_service) {
if (install_smsd_service(¶ms)) {
printf("Service %s installed sucessfully\n", smsd_service_name);
exit(0);
} else {
printf("Error installing %s service\n", smsd_service_name);
service_print_error("Error installing service");
exit(1);
}
}
if (params.start_service) {
if (start_smsd_service()) {
printf("Service %s started sucessfully\n", smsd_service_name);
exit(0);
} else {
printf("Error starting %s service\n", smsd_service_name);
service_print_error("Error starting service");
exit(1);
}
}
#endif
read_config:
config = SMSD_NewConfig(program_name);
assert(config != NULL);
error = SMSD_ReadConfig(params.config_file, config, params.use_log);
if (error != ERR_NONE) {
printf("Failed to read config: %s\n", GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 2;
}
if (!reconfigure)
configure_daemon(¶ms);
reconfigure = FALSE;
standby = FALSE;
error = SMSD_MainLoop(config, FALSE, params.max_failures);
if (error != ERR_NONE) {
printf("Failed to run SMSD: %s\n", GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 2;
}
SMSD_FreeConfig(config);
/*
* Wait while we should be suspended.
* Later we fall back to reconfigure bellow.
*/
while (standby) {
sleep(1);
}
if (reconfigure) {
goto read_config;
}
return 0;
}
int main(int argc, char** argv) {
static const char kRunfiles[] = ".runfiles/org_deepmind_lab";
static EnvCApi env_c_api;
static void* context;
static char runfiles_path[4096];
if (sizeof(runfiles_path) < strlen(argv[0]) + sizeof(kRunfiles)) {
sys_error("Runfiles directory name too long!");
}
strcpy(runfiles_path, argv[0]);
strcat(runfiles_path, kRunfiles);
DeepMindLabLaunchParams params;
params.runfiles_path = runfiles_path;
if (dmlab_connect(¶ms, &env_c_api, &context) != 0) {
sys_error("Failed to connect RL API");
}
if (env_c_api.setting(context, "width", "640") != 0) {
sys_error("Failed to apply default 'width' setting.");
}
if (env_c_api.setting(context, "height", "480") != 0) {
sys_error("Failed to apply default 'height' setting.");
}
if (env_c_api.setting(context, "controls", "internal") != 0) {
sys_error("Failed to apply 'controls' setting.");
}
if (env_c_api.setting(context, "appendCommand", " +set com_maxfps \"250\"")
!= 0) {
sys_error("Failed to apply 'appendCommand' setting.");
}
int num_episodes = 1;
int seed = 1;
process_commandline(argc, argv, &env_c_api, context, &num_episodes, &seed);
if (env_c_api.init(context) != 0) {
sys_error("Failed to init RL API");
}
for (int episode = 0; episode < num_episodes; ++episode, ++seed) {
if (env_c_api.start(context, episode, seed) != 0) {
sys_error("Failed to start environment.");
}
printf("Episode: %d\n", episode);
double score = 0;
double reward;
while (env_c_api.advance(context, 1, &reward) ==
EnvCApi_EnvironmentStatus_Running) {
if (reward != 0.0) {
score += reward;
printf("Score: %f\n", score);
fflush(stdout);
}
}
}
env_c_api.release_context(context);
}
int process_commandline(int argc, char **argv, SMSD_Parameters * params)
{
int opt;
#ifdef HAVE_GETOPT_LONG
struct option long_options[] = {
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{"config", 1, 0, 'c'},
{"delay", 1, 0, 'd'},
{"loops", 1, 0, 'l'},
{0, 0, 0, 0}
};
int option_index;
while ((opt =
getopt_long(argc, argv, "+hvc:d:l:C", long_options,
&option_index)) != -1) {
#elif defined(HAVE_GETOPT)
while ((opt = getopt(argc, argv, "+hvc:d:l:C")) != -1) {
#else
/* Poor mans getopt replacement */
int i, optind = -1;
#define optarg argv[++i]
for (i = 1; i < argc; i++) {
if (strlen(argv[i]) != 2 || argv[i][0] != '-') {
wrong_params();
}
opt = argv[i][1];
#endif
switch (opt) {
case 'c':
params->config_file = optarg;
break;
case 'v':
version();
break;
case 'C':
compact = TRUE;
break;
case 'd':
delay_seconds = atoi(optarg);
break;
case 'l':
limit_loops = atoi(optarg);
break;
case '?':
wrong_params();
case 'h':
help();
exit(0);
default:
#if defined(HAVE_GETOPT) || defined(HAVE_GETOPT_LONG)
wrong_params();
#else
optind = 1;
#endif
break;
}
#if !defined(HAVE_GETOPT) && !defined(HAVE_GETOPT_LONG)
if (optind != -1) break;
#endif
}
return optind;
}
#ifndef WIN32
#endif
int main(int argc, char **argv)
{
GSM_Error error;
GSM_SMSDConfig *config;
GSM_SMSDStatus status;
const char program_name[] = "gammu-smsd-monitor";
SMSD_Parameters params = {
NULL,
NULL,
-1,
-1,
NULL,
NULL,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
0
};
/*
* We don't need gettext, but need to set locales so that
* charset conversion works.
*/
GSM_InitLocales(NULL);
process_commandline(argc, argv, ¶ms);
if (params.config_file == NULL) {
#ifdef HAVE_DEFAULT_CONFIG
params.config_file = default_config;
#else
fprintf(stderr, "No config file specified!\n");
help();
exit(1);
#endif
}
signal(SIGINT, smsd_interrupt);
signal(SIGTERM, smsd_interrupt);
config = SMSD_NewConfig(program_name);
assert(config != NULL);
error = SMSD_ReadConfig(params.config_file, config, TRUE);
if (error != ERR_NONE) {
printf("Failed to read config: %s\n", GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 2;
}
while (!terminate && (limit_loops == -1 || limit_loops-- > 0)) {
error = SMSD_GetStatus(config, &status);
if (error != ERR_NONE) {
printf("Failed to get status: %s\n", GSM_ErrorString(error));
SMSD_FreeConfig(config);
return 3;
}
if (compact) {
printf("%s;%s;%s;%d;%d;%d;%d;%d\n",
status.Client,
status.PhoneID,
status.IMEI,
status.Sent,
status.Received,
status.Failed,
status.Charge.BatteryPercent,
status.Network.SignalPercent);
} else {
printf("Client: %s\n", status.Client);
printf("PhoneID: %s\n", status.PhoneID);
printf("IMEI: %s\n", status.IMEI);
printf("Sent: %d\n", status.Sent);
printf("Received: %d\n", status.Received);
printf("Failed: %d\n", status.Failed);
printf("BatterPercent: %d\n", status.Charge.BatteryPercent);
printf("NetworkSignal: %d\n", status.Network.SignalPercent);
printf("\n");
}
sleep(delay_seconds);
}
SMSD_FreeConfig(config);
return 0;
}
/* Function: main()
* Synopsis: break input sequence set into chunks, for each one building the
* Burrows-Wheeler transform and corresponding FM-index. Maintain requisite
* meta data.
* Notes: Currently depends on the divsufsort-lite code of Yuta Mori, though this
* could easily be replaced.
*/
int
main(int argc, char **argv)
{
char tmp_filename[16] = "fmtmpXXXXXX";
FILE *fptmp = NULL;
FILE *fp = NULL;
uint8_t *T = NULL;
uint8_t *BWT = NULL;
int *SA = NULL; //what I write will be 32-bit ints, but I need to keep this as int so it'll work with libdivsufsort
uint32_t *SAsamp = NULL;
uint32_t *occCnts_sb = NULL; // same indexing as above
uint32_t *cnts_sb = NULL;
uint16_t *occCnts_b = NULL; // this is logically a 2D array, but will be indexed as occ_cnts[alph_size*index + char] (instead of occ_cnts[index][char])
uint16_t *cnts_b = NULL;
FM_METADATA *meta = NULL;
clock_t t1, t2;
struct tms ts1, ts2;
long i,j,c;
int status = eslOK;
int chars_per_byte;
int num_freq_cnts_sb ;
int num_freq_cnts_b ;
int num_SA_samples ;
int infmt = eslSQFILE_UNKNOWN;
int alphatype = eslUNKNOWN;
int alphaguess =eslUNKNOWN;
ESL_ALPHABET *abc = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
ESL_SQ *tmpsq = NULL;
ESL_SQ_BLOCK *block = NULL;
char *fname_in = NULL;
char *fname_out= NULL;
int block_size = 50000000;
int sq_cnt = 0;
int use_tmpsq = 0;
uint64_t block_length;
uint64_t total_char_count = 0;
int max_block_size;
int numblocks = 0;
uint32_t numseqs = 0;
int allocedseqs = 1000;
uint32_t seq_offset = 0;
uint32_t ambig_offset = 0;
uint32_t overlap = 0;
uint16_t seq_cnt;
uint16_t ambig_cnt;
uint32_t prev_numseqs = 0;
int compressed_bytes;
uint32_t term_loc;
ESL_GETOPTS *go = NULL; /* command line processing */
uint8_t ambig_repl = 0;
int in_ambig_run = 0;
FM_AMBIGLIST ambig_list;
ESL_ALLOC (meta, sizeof(FM_METADATA));
if (meta == NULL)
esl_fatal("unable to allocate memory to store FM meta data\n");
ESL_ALLOC (meta->ambig_list, sizeof(FM_AMBIGLIST));
if (meta->ambig_list == NULL)
esl_fatal("unable to allocate memory to store FM ambiguity data\n");
fm_initAmbiguityList(meta->ambig_list);
meta->alph_type = fm_DNA;
meta->freq_SA = 8;
meta->freq_cnt_b = 256;
meta->freq_cnt_sb = pow(2,16); //65536 - that's the # values in a short
meta->seq_count = 0;
ESL_ALLOC (meta->seq_data, allocedseqs * sizeof(FM_SEQDATA));
if (meta->seq_data == NULL )
esl_fatal("unable to allocate memory to store FM sequence data\n");
process_commandline(argc, argv, &go, &fname_in, &fname_out);
if (esl_opt_IsOn(go, "--bin_length")) meta->freq_cnt_b = esl_opt_GetInteger(go, "--bin_length");
if ( meta->freq_cnt_b < 32 || meta->freq_cnt_b >4096 || (meta->freq_cnt_b & (meta->freq_cnt_b - 1)) ) // test power of 2
esl_fatal("bin_length must be a power of 2, at least 128, and at most 4096\n");
if (esl_opt_IsOn(go, "--sa_freq")) meta->freq_SA = esl_opt_GetInteger(go, "--sa_freq");
if ( (meta->freq_SA & (meta->freq_SA - 1)) ) // test power of 2
esl_fatal ("SA_freq must be a power of 2\n");
if (esl_opt_IsOn(go, "--block_size")) block_size = 1000000 * esl_opt_GetInteger(go, "--block_size");
if ( block_size <=0 )
esl_fatal ("block_size must be a positive number\n");
//start timer
t1 = times(&ts1);
output_header(stdout, go, fname_in, fname_out);
if (esl_opt_GetString(go, "--informat") != NULL) {
infmt = esl_sqio_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (infmt == eslSQFILE_UNKNOWN) esl_fatal("%s is not a valid input sequence file format for --informat");
}
status = esl_sqfile_Open(fname_in, infmt, NULL, &sqfp);
if (status == eslENOTFOUND) esl_fatal("No such file %s", fname_in);
else if (status == eslEFORMAT) esl_fatal("Format of seqfile %s unrecognized.", fname_in);
else if (status != eslOK) esl_fatal("Open failed, code %d.", status);
meta->fwd_only = 0;
if (esl_opt_IsUsed(go, "--alph")) {
meta->alph = esl_opt_GetString(go, "--alph") ;
if ( esl_strcmp(meta->alph, "dna")==0 || esl_strcmp(meta->alph, "rna")==0) {
meta->alph_type = fm_DNA;
alphatype = eslDNA;
} else if (esl_strcmp(meta->alph, "dna_full")==0 || esl_strcmp(meta->alph, "rna_full")==0) {
meta->alph_type = fm_DNA_full;
alphatype = eslDNA;
} else if (esl_strcmp(meta->alph, "amino")==0) {
meta->alph_type = fm_AMINO;
alphatype = eslAMINO;
meta->fwd_only = 1;
} else {
esl_fatal("Unknown alphabet type. Try 'dna', 'dna_full', or 'amino'\n%s", "");
}
} else {
esl_sqfile_GuessAlphabet(sqfp, &alphaguess);
if (alphaguess == eslDNA || alphaguess == eslRNA) {
meta->alph_type = fm_DNA;
alphatype = eslDNA;
} else if (alphaguess == eslAMINO) {
meta->alph_type = fm_AMINO;
alphatype = eslAMINO;
meta->fwd_only = 1;
} else {
esl_fatal("Unknown alphabet type. Try 'dna', 'dna_full', or 'amino'\n%s", "");
}
}
if (esl_opt_IsOn(go, "--fwd_only") )
meta->fwd_only = 1;
meta->alph = NULL;
//getInverseAlphabet
fm_alphabetCreate(meta, &(meta->charBits));
chars_per_byte = 8/meta->charBits;
//shift inv_alph up one, to make space for '$' at 0
for (i=0; i<256; i++)
if ( meta->inv_alph[i] >= 0)
meta->inv_alph[i]++;
abc = esl_alphabet_Create(alphatype);
sq = esl_sq_CreateDigital(abc);
tmpsq = esl_sq_CreateDigital(abc);
esl_sqfile_SetDigital(sqfp, abc);
block = esl_sq_CreateDigitalBlock(FM_BLOCK_COUNT, abc);
block->complete = FALSE;
// max_block_size = FM_BLOCK_OVERLAP+block_size+1 + block_size*.2; // +1 for the '$'
max_block_size = FM_BLOCK_OVERLAP+block_size+1 + block_size; // temporary hack to avoid memory over-runs (see end of 1101_fmindex_benchmarking/00NOTES)
if (alphatype == fm_DNA)
fm_initAmbiguityList(&ambig_list);
/* Allocate BWT, Text, SA, and FM-index data structures, allowing storage of maximally large sequence*/
ESL_ALLOC (T, max_block_size * sizeof(uint8_t));
ESL_ALLOC (BWT, max_block_size * sizeof(uint8_t));
ESL_ALLOC (SA, max_block_size * sizeof(int));
ESL_ALLOC (SAsamp, (1+floor((double)max_block_size/meta->freq_SA) ) * sizeof(uint32_t));
ESL_ALLOC (occCnts_sb, (1+ceil((double)max_block_size/meta->freq_cnt_sb)) * meta->alph_size * sizeof(uint32_t)); // every freq_cnt_sb positions, store an array of ints
ESL_ALLOC (cnts_sb, meta->alph_size * sizeof(uint32_t));
ESL_ALLOC (occCnts_b, ( 1+ceil((double)max_block_size/meta->freq_cnt_b)) * meta->alph_size * sizeof(uint16_t)); // every freq_cnt_b positions, store an array of 8-byte ints
ESL_ALLOC (cnts_b, meta->alph_size * sizeof(uint16_t));
if((T == NULL) || (BWT == NULL) || (SA==NULL) || (SAsamp==NULL) || (BWT==NULL) || (cnts_b==NULL) || (occCnts_b==NULL) || (cnts_sb==NULL) || (occCnts_sb==NULL) ) {
esl_fatal( "%s: Cannot allocate memory.\n", argv[0]);
}
// Open a temporary file, to which FM-index data will be written
if (esl_tmpfile(tmp_filename, &fptmp) != eslOK) esl_fatal("unable to open fm-index tmpfile");
/* Main loop: */
while (status == eslOK ) {
//reset block as an empty vessel
for (i=0; i<block->count; i++)
esl_sq_Reuse(block->list + i);
if (use_tmpsq) {
esl_sq_Copy(tmpsq , block->list);
block->complete = FALSE; //this lets ReadBlock know that it needs to append to a small bit of previously-read seqeunce
block->list->C = FM_BLOCK_OVERLAP; // overload the ->C value, which ReadBlock uses to determine how much
// overlap should be retained in the ReadWindow step
} else {
block->complete = TRUE;
}
status = esl_sqio_ReadBlock(sqfp, block, block_size, -1, alphatype != eslAMINO);
if (status == eslEOF) continue;
if (status != eslOK) ESL_XEXCEPTION(status, "failure reading sequence block");
seq_offset = numseqs;
ambig_offset = meta->ambig_list->count;
if (block->complete || block->count == 0) {
use_tmpsq = FALSE;
} else {
/* The final sequence on the block was a probably-incomplete window of the active sequence.
* Grab a copy of the end for use in the next pass, to ensure we don't miss hits crossing
* the boundary between two blocks.
*/
esl_sq_Copy(block->list + (block->count - 1) , tmpsq);
use_tmpsq = TRUE;
}
block->first_seqidx = sq_cnt;
sq_cnt += block->count - (use_tmpsq ? 1 : 0);// if there's an incomplete sequence read into the block wait to count it until it's complete.
/* Read dseqs from block into text element T.
* Convert the dsq from esl-alphabet to fm-alphabet (1..k for alphabet of size k).
* (a) collapsing upper/lower case for appropriate sorting.
* (b) reserving 0 for '$', which must be lexicographically smallest
* (these will later be shifted to 0-based alphabet, once SA has been built)
*
*/
block_length = 0;
for (i=0; i<block->count; i++) {
//start a new block, with space for the name
allocateSeqdata(meta, block->list+i, numseqs, &allocedseqs);
//meta data
meta->seq_data[numseqs].target_id = block->first_seqidx + i ;
meta->seq_data[numseqs].target_start = block->list[i].start;
meta->seq_data[numseqs].fm_start = block_length;
if (block->list[i].name == NULL) meta->seq_data[numseqs].name[0] = '\0';
else strcpy(meta->seq_data[numseqs].name, block->list[i].name );
if (block->list[i].acc == NULL) meta->seq_data[numseqs].acc[0] = '\0';
else strcpy(meta->seq_data[numseqs].acc, block->list[i].acc );
if (block->list[i].source == NULL) meta->seq_data[numseqs].source[0] = '\0';
else strcpy(meta->seq_data[numseqs].source, block->list[i].source );
if (block->list[i].desc == NULL) meta->seq_data[numseqs].desc[0] = '\0';
else strcpy(meta->seq_data[numseqs].desc, block->list[i].desc );
for (j=1; j<=block->list[i].n; j++) {
c = abc->sym[block->list[i].dsq[j]];
if ( meta->alph_type == fm_DNA) {
if (meta->inv_alph[c] == -1) {
// replace ambiguity characters by rotating through A,C,G, and T.
c = meta->alph[ambig_repl];
ambig_repl = (ambig_repl+1)%4;
if (!in_ambig_run) {
fm_addAmbiguityRange(meta->ambig_list, block_length, block_length);
in_ambig_run=1;
} else {
meta->ambig_list->ranges[meta->ambig_list->count - 1].upper = block_length;
}
} else {
in_ambig_run=0;
}
} else if (meta->inv_alph[c] == -1) {
esl_fatal("requested alphabet doesn't match input text\n");
}
T[block_length] = meta->inv_alph[c];
block_length++;
if (j>block->list[i].C) total_char_count++; // add to total count, only if it's not redundant with earlier read
meta->seq_data[numseqs].length++;
}
numseqs++;
}
T[block_length] = 0; // last character 0 is effectively '$' for suffix array
block_length++;
seq_cnt = numseqs-seq_offset;
ambig_cnt = meta->ambig_list->count - ambig_offset;
//build and write FM-index for T. This will be a BWT on the reverse of the sequence, required for reverse-traversal of the BWT
buildAndWriteFMIndex(meta, seq_offset, ambig_offset, seq_cnt, ambig_cnt, (uint32_t)block->list[0].C, T, BWT, SA, SAsamp,
occCnts_sb, cnts_sb, occCnts_b, cnts_b, block_length, fptmp);
if ( ! meta->fwd_only ) {
//build and write FM-index for un-reversed T (used to find reverse hits using forward traversal of the BWT
buildAndWriteFMIndex(meta, seq_offset, ambig_offset, seq_cnt, ambig_cnt, 0, T, BWT, SA, NULL,
occCnts_sb, cnts_sb, occCnts_b, cnts_b, block_length, fptmp);
}
prev_numseqs = numseqs;
numblocks++;
}
esl_sqfile_Close(sqfp);
esl_alphabet_Destroy(abc);
esl_sq_Destroy(sq);
esl_sq_Destroy(tmpsq);
esl_sq_DestroyBlock(block);
meta->seq_count = numseqs;
meta->block_count = numblocks;
/* Finished writing the FM-index data to a temporary file. Now write
* metadata to fname_out, than append FM-index data from temp file
*/
if((fp = fopen(fname_out, "wb")) == NULL)
esl_fatal( "%s: Cannot open file `%s': ", argv[0], fname_out);
//write out meta data
if( fwrite(&(meta->fwd_only), sizeof(meta->fwd_only), 1, fp) != 1 ||
fwrite(&(meta->alph_type), sizeof(meta->alph_type), 1, fp) != 1 ||
fwrite(&(meta->alph_size), sizeof(meta->alph_size), 1, fp) != 1 ||
fwrite(&(meta->charBits), sizeof(meta->charBits), 1, fp) != 1 ||
fwrite(&(meta->freq_SA), sizeof(meta->freq_SA), 1, fp) != 1 ||
fwrite(&(meta->freq_cnt_sb), sizeof(meta->freq_cnt_sb), 1, fp) != 1 ||
fwrite(&(meta->freq_cnt_b), sizeof(meta->freq_cnt_b), 1, fp) != 1 ||
fwrite(&(meta->block_count), sizeof(meta->block_count), 1, fp) != 1 ||
fwrite(&(meta->seq_count), sizeof(meta->seq_count), 1, fp) != 1 ||
fwrite(&(meta->ambig_list->count), sizeof(meta->ambig_list->count), 1, fp) != 1 ||
fwrite(&total_char_count, sizeof(total_char_count), 1, fp) != 1
)
esl_fatal( "%s: Error writing meta data for FM index.\n", argv[0]);
for (i=0; i<meta->seq_count; i++) {
if( fwrite(&(meta->seq_data[i].target_id), sizeof(meta->seq_data[i].target_id), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].target_start), sizeof(meta->seq_data[i].target_start), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].fm_start), sizeof(meta->seq_data[i].fm_start), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].length), sizeof(meta->seq_data[i].length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].name_length), sizeof(meta->seq_data[i].name_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].acc_length), sizeof(meta->seq_data[i].acc_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].source_length),sizeof(meta->seq_data[i].source_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].desc_length), sizeof(meta->seq_data[i].desc_length), 1, fp) != 1 ||
fwrite(meta->seq_data[i].name, sizeof(char), meta->seq_data[i].name_length+1 , fp) != meta->seq_data[i].name_length+1 ||
fwrite(meta->seq_data[i].acc, sizeof(char), meta->seq_data[i].acc_length+1 , fp) != meta->seq_data[i].acc_length+1 ||
fwrite(meta->seq_data[i].source, sizeof(char), meta->seq_data[i].source_length+1, fp) != meta->seq_data[i].source_length+1 ||
fwrite(meta->seq_data[i].desc, sizeof(char), meta->seq_data[i].desc_length+1 , fp) != meta->seq_data[i].desc_length+1
)
esl_fatal( "%s: Error writing meta data for FM index.\n", argv[0]);
}
for (i=0; i<meta->ambig_list->count; i++) {
if( fwrite(&(meta->ambig_list->ranges[i].lower), sizeof(meta->ambig_list->ranges[i].lower), 1, fp) != 1 ||
fwrite(&(meta->ambig_list->ranges[i].upper), sizeof(meta->ambig_list->ranges[i].upper), 1, fp) != 1
)
esl_fatal( "%s: Error writing ambiguity data for FM index.\n", argv[0]);
}
/* now append the FM-index data in fptmp to the desired output file, fp */
rewind(fptmp);
for (i=0; i<numblocks; i++) {
for(j=0; j< (meta->fwd_only?1:2); j++ ) { //do this once or twice, once for forward-T index, and possibly once for reversed
//first, read
if(fread(&block_length, sizeof(block_length), 1, fptmp) != 1)
esl_fatal( "%s: Error reading block_length in FM index.\n", argv[0]);
if(fread(&term_loc, sizeof(term_loc), 1, fptmp) != 1)
esl_fatal( "%s: Error reading terminal location in FM index.\n", argv[0]);
if(fread(&seq_offset, sizeof(seq_offset), 1, fptmp) != 1)
esl_fatal( "%s: Error reading seq_offset in FM index.\n", argv[0]);
if(fread(&ambig_offset, sizeof(ambig_offset ), 1, fptmp) != 1)
esl_fatal( "%s: Error reading ambig_offset in FM index.\n", argv[0]);
if(fread(&overlap, sizeof(overlap), 1, fptmp) != 1)
esl_fatal( "%s: Error reading overlap in FM index.\n", argv[0]);
if(fread(&seq_cnt, sizeof(seq_cnt), 1, fptmp) != 1)
esl_fatal( "%s: Error reading seq_cnt in FM index.\n", argv[0]);
if(fread(&ambig_cnt, sizeof(ambig_cnt), 1, fptmp) != 1)
esl_fatal( "%s: Error reading ambig_cnt in FM index.\n", argv[0]);
compressed_bytes = ((chars_per_byte-1+block_length)/chars_per_byte);
num_freq_cnts_b = 1+ceil((double)block_length/meta->freq_cnt_b);
num_freq_cnts_sb = 1+ceil((double)block_length/meta->freq_cnt_sb);
num_SA_samples = 1+floor((double)block_length/meta->freq_SA);
//j==0 test cause T and SA to be written only for forward sequence
if(j==0 && fread(T, sizeof(uint8_t), compressed_bytes, fptmp) != compressed_bytes)
esl_fatal( "%s: Error reading T in FM index.\n", argv[0]);
if(fread(BWT, sizeof(uint8_t), compressed_bytes, fptmp) != compressed_bytes)
esl_fatal( "%s: Error reading BWT in FM index.\n", argv[0]);
if(j==0 && fread(SAsamp, sizeof(uint32_t), (size_t)num_SA_samples, fptmp) != (size_t)num_SA_samples)
esl_fatal( "%s: Error reading SA in FM index.\n", argv[0]);
if(fread(occCnts_b, sizeof(uint16_t)*(meta->alph_size), (size_t)num_freq_cnts_b, fptmp) != (size_t)num_freq_cnts_b)
esl_fatal( "%s: Error reading occCnts_b in FM index.\n", argv[0]);
if(fread(occCnts_sb, sizeof(uint32_t)*(meta->alph_size), (size_t)num_freq_cnts_sb, fptmp) != (size_t)num_freq_cnts_sb)
esl_fatal( "%s: Error reading occCnts_sb in FM index.\n", argv[0]);
//then, write
if(fwrite(&block_length, sizeof(block_length), 1, fp) != 1)
esl_fatal( "%s: Error writing block_length in FM index.\n", argv[0]);
if(fwrite(&term_loc, sizeof(term_loc), 1, fp) != 1)
esl_fatal( "%s: Error writing terminal location in FM index.\n", argv[0]);
if(fwrite(&seq_offset, sizeof(seq_offset), 1, fp) != 1)
esl_fatal( "%s: Error writing seq_offset in FM index.\n", argv[0]);
if(fwrite(&ambig_offset, sizeof(ambig_offset), 1, fp) != 1)
esl_fatal( "%s: Error writing ambig_offset in FM index.\n", argv[0]);
if(fwrite(&overlap, sizeof(overlap), 1, fp) != 1)
esl_fatal( "%s: Error writing overlap in FM index.\n", argv[0]);
if(fwrite(&seq_cnt, sizeof(seq_cnt), 1, fp) != 1)
esl_fatal( "%s: Error writing seq_cnt in FM index.\n", argv[0]);
if(fwrite(&ambig_cnt, sizeof(ambig_cnt), 1, fp) != 1)
esl_fatal( "%s: Error writing ambig_cnt in FM index.\n", argv[0]);
if(j==0 && fwrite(T, sizeof(uint8_t), compressed_bytes, fp) != compressed_bytes)
esl_fatal( "%s: Error writing T in FM index.\n", argv[0]);
if(fwrite(BWT, sizeof(uint8_t), compressed_bytes, fp) != compressed_bytes)
esl_fatal( "%s: Error writing BWT in FM index.\n", argv[0]);
if(j==0 && fwrite(SAsamp, sizeof(uint32_t), (size_t)num_SA_samples, fp) != (size_t)num_SA_samples)
esl_fatal( "%s: Error writing SA in FM index.\n", argv[0]);
if(fwrite(occCnts_b, sizeof(uint16_t)*(meta->alph_size), (size_t)num_freq_cnts_b, fp) != (size_t)num_freq_cnts_b)
esl_fatal( "%s: Error writing occCnts_b in FM index.\n", argv[0]);
if(fwrite(occCnts_sb, sizeof(uint32_t)*(meta->alph_size), (size_t)num_freq_cnts_sb, fp) != (size_t)num_freq_cnts_sb)
esl_fatal( "%s: Error writing occCnts_sb in FM index.\n", argv[0]);
}
}
fprintf (stderr, "Number of characters in index: %ld\n", (long)total_char_count);
fprintf (stderr, "Number of FM-index blocks: %ld\n", (long)meta->block_count);
fclose(fp);
fclose(fptmp);
free(T);
free(BWT);
free(SA);
free(SAsamp);
free(occCnts_b);
free(cnts_b);
free(occCnts_sb);
free(cnts_sb);
fm_metaDestroy(meta);
esl_getopts_Destroy(go);
// compute and print the elapsed time in millisec
t2 = times(&ts2);
{
double clk_ticks = sysconf(_SC_CLK_TCK);
double elapsedTime = (t2-t1)/clk_ticks;
fprintf (stderr, "run time: %.2f seconds\n", elapsedTime);
}
return (eslOK);
ERROR:
/* Deallocate memory. */
if (fp) fclose(fp);
if (T) free(T);
if (BWT) free(BWT);
if (SA) free(SA);
if (SAsamp) free(SAsamp);
if (occCnts_b) free(occCnts_b);
if (cnts_b) free(cnts_b);
if (occCnts_sb) free(occCnts_sb);
if (cnts_sb) free(cnts_sb);
if (ambig_list.ranges) free(ambig_list.ranges);
fm_metaDestroy(meta);
esl_getopts_Destroy(go);
esl_sqfile_Close(sqfp);
esl_alphabet_Destroy(abc);
esl_sq_Destroy(sq);
if (tmpsq) esl_sq_Destroy(tmpsq);
if (block) esl_sq_DestroyBlock(block);
fprintf (stderr, "failure during memory allocation\n");
exit(status);
}
/** MAIN */
int main( int argc, char **argv)
{
int i, frame_count;
int horz, vert; /* width and height of the frame */
uint8_t *frame[3]; /*pointer to the 3 color planes of the input frame */
struct area_s inarea;
struct color_yuv coloryuv;
int input_fd = 0; /* std in */
int output_fd = 1; /* std out */
int darker = 0; /* how much darker should the image be */
int copy_pixel = 0; /* how much pixels we should use for filling up the area */
int average_pixel = 0; /* how much pixel to use for average */
y4m_stream_info_t istream, ostream;
y4m_frame_info_t iframe;
inarea.width=0; inarea.height=0; inarea.voffset=0; inarea.hoffset=0;
coloryuv.luma = LUMA; /*Setting the luma to black */
coloryuv.chroma_b = CHROMA; /*Setting the chroma to center, means white */
coloryuv.chroma_r = CHROMA; /*Setting the chroma to center, means white */
(void)mjpeg_default_handler_verbosity(verbose);
/* processing commandline */
process_commandline(argc, argv, &inarea, &darker, ©_pixel, &coloryuv,
&average_pixel);
y4m_init_stream_info(&istream);
y4m_init_stream_info(&ostream);
y4m_init_frame_info(&iframe);
/* First read the header of the y4m stream */
i = y4m_read_stream_header(input_fd, &istream);
if ( i != Y4M_OK) /* a basic check if we really have y4m stream */
mjpeg_error_exit1("Input stream error: %s", y4m_strerr(i));
else
{
/* Here we copy the input stream info to the output stream info header */
y4m_copy_stream_info(&ostream, &istream);
/* Here we write the new output header to the output fd */
y4m_write_stream_header(output_fd, &ostream);
horz = y4m_si_get_width(&istream); /* get the width of the frame */
vert = y4m_si_get_height(&istream); /* get the height of the frame */
if ( (inarea.width + inarea.hoffset) > horz)
mjpeg_error_exit1("Input width and offset larger than framewidth,exit");
if ( (inarea.height + inarea.voffset) > vert)
mjpeg_error_exit1("Input height and offset larger than frameheight,exit");
/* Here we allocate the memory for on frame */
frame[0] = malloc( horz * vert );
frame[1] = malloc( (horz/2) * (vert/2) );
frame[2] = malloc( (horz/2) * (vert/2) );
/* Here we set the initial number of of frames */
/* We do not need it. Just for showing that is does something */
frame_count = 0 ;
/* This is the main loop here can filters effects, scaling and so
on be done with the video frames. Just up to your mind */
/* We read now a single frame with the header and check if it does not
have any problems or we have alreaddy processed the last without data */
while(y4m_read_frame(input_fd, &istream, &iframe, frame) == Y4M_OK)
{
frame_count++;
/* You can do something usefull here */
if (darker != 0)
set_darker(inarea, horz, vert, frame, darker);
else if (copy_pixel != 0)
copy_area(inarea, horz, vert, frame, copy_pixel);
else if (average_pixel != 0)
average_area(inarea, horz, vert, frame, average_pixel);
else
set_inactive(inarea, horz, vert, frame, &coloryuv);
/* Now we put out the read frame */
y4m_write_frame(output_fd, &ostream, &iframe, frame);
}
/* Cleaning up the data structures */
y4m_fini_stream_info(&istream);
y4m_fini_stream_info(&ostream);
y4m_fini_frame_info(&iframe);
}
/* giving back the memory to the system */
free(frame[0]);
frame[0] = 0;
free(frame[1]);
frame[1] = 0;
free(frame[2]);
frame[2] = 0;
exit(0); /* exiting */
}