void osc_veejay_select( void *info,const char *path, const char *types, void **dargv, void *raw)
{
lo_arg **argv = (lo_arg**) dargv;
int id = argv[0]->i;
veejay_t *v = (veejay_t*) info;
void *sample = v->current_sample;
void *res = sample;
if( id > 0 )
{
res = find_sample( id );
}
else if( id == -1 )
res = sample_last();
if(sample == res)
{
uint64_t pos = sample_get_start_pos( v->current_sample );
sample_set_property_ptr(
v->current_sample, "current_pos", VEVO_ATOM_TYPE_UINT64, &pos );
}
else
{
veejay_msg(VEEJAY_MSG_INFO, "Play sample %d", id );
// sample_save_cache_data( v->current_sample );
v->current_sample = res;
}
}
void osc_veejay_ui_blreq_window( void *info, const char *path, const char *types, void **dargv, void *raw )
{
veejay_t *v = (veejay_t*) info;
lo_arg **argv = (lo_arg**) dargv;
void *sample = find_sample( argv[0]->i );
if(!sample)
{
veejay_msg(0,"sample %d does not exist",argv[0]->i);
return;
}
vevosample_ui_get_bind_list( sample, (char*) &argv[1]->s );
}
void osc_veejay_del_sample(void *info,const char *path, const char *types, void **dargv, void *raw)
{
lo_arg **argv = (lo_arg**) dargv;
int id = argv[0]->i;
veejay_t *v = (veejay_t*) info;
void *sample = find_sample(id);
if(sample == v->current_sample)
veejay_msg(0, "Cannot delete current playing sample");
else
if(sample_delete( id ) )
veejay_msg(0, "Deleted sample %d", id );
}
void osc_veejay_ui_ipreq_window( void *info, const char *path, const char *types, void **dargv, void *raw )
{
veejay_t *v = (veejay_t*) info;
lo_arg **argv = (lo_arg**) dargv;
void *sample = find_sample( argv[0]->i );
if(!sample)
{
veejay_msg(0,"sample %d does not exist",argv[0]->i);
return;
}
if( sample_has_fx( sample, argv[1]->i ))
{
vevosample_ui_get_input_parameter_list( sample, argv[1]->i, (char*) &argv[2]->s );
}
}
void osc_veejay_clone_sample( void *info, const char *path, const char *types, void **dargv, void *raw )
{
veejay_t *v = (veejay_t*) info;
lo_arg **argv = (lo_arg**) dargv;
void *sample = find_sample( argv[0]->i );
if(!sample)
{
veejay_msg(0,"sample %d does not exist",argv[0]->i);
return;
}
if( sample_clone_from( v, sample, v->video_info ))
{
veejay_msg(0, "Cloned sample %d" );
}
}
void osc_veejay_ui_bindreq_window( void *info, const char *path, const char *types, void **dargv, void *raw )
{
veejay_t *v = (veejay_t*) info;
lo_arg **argv = (lo_arg**) dargv;
void *sample = find_sample( argv[0]->i );
if(!sample)
{
veejay_msg(0,"sample %d does not exist",argv[0]->i);
return;
}
if( sample_has_fx( sample, argv[1]->i ))
{
vevosample_ui_construct_fx_bind_window( sample, argv[1]->i, argv[2]->i );
}
else
veejay_msg(0, "FX %d on sample %d not active", argv[0]->i,
argv[1]->i);
}
void clamav_stats_decrement_count(const char *virname, const unsigned char *md5, size_t size, void *cbdata)
{
cli_intel_t *intel;
cli_flagged_sample_t *sample;
int err;
intel = (cli_intel_t *)cbdata;
if (!(intel))
return;
#ifdef CL_THREAD_SAFE
err = pthread_mutex_lock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_decrement_count: locking mutex failed (err: %d): %s\n", err, strerror(err));
return;
}
#endif
sample = find_sample(intel, virname, md5, size, NULL);
if (!(sample))
goto clamav_stats_decrement_end;
if (sample->hits == 1) {
if ((intel->engine->cb_stats_remove_sample))
intel->engine->cb_stats_remove_sample(virname, md5, size, intel);
else
clamav_stats_remove_sample(virname, md5, size, intel);
goto clamav_stats_decrement_end;
}
sample->hits--;
clamav_stats_decrement_end:
#ifdef CL_THREAD_SAFE
err = pthread_mutex_unlock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_decrement_count: unlocking mutex failed (err: %d): %s\n", err, strerror(err));
}
#endif
return;
}
void osc_sample_channel_fx_entry( void *sample,const char *path, const char *types, void **dargv, void *raw)
{
lo_arg **argv = (lo_arg**) dargv;
int fx_id = sample_extract_fx_entry_from_path(sample, path );
if( fx_id < 0 )
{
veejay_msg(VEEJAY_MSG_ERROR, "Outside chain boundary");
return;
}
int seq = argv[0]->i;
int id = argv[1]->i;
if( find_sample(id) )
{
int n = sample_fx_set_in_channel( sample, fx_id, seq,id );
if(n)
veejay_msg(VEEJAY_MSG_ERROR, "Input channel %d set to sample %d", seq, id );
}
}
void clamav_stats_remove_sample(const char *virname, const unsigned char *md5, size_t size, void *cbdata)
{
cli_intel_t *intel;
cli_flagged_sample_t *sample;
int err;
intel = (cli_intel_t *)cbdata;
if (!(intel))
return;
#ifdef CL_THREAD_SAFE
err = pthread_mutex_lock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_remove_sample: locking mutex failed (err: %d): %s\n", err, strerror(err));
return;
}
#endif
while ((sample = find_sample(intel, virname, md5, size, NULL))) {
if (sample->prev)
sample->prev->next = sample->next;
if (sample->next)
sample->next->prev = sample->prev;
if (sample == intel->samples)
intel->samples = sample->next;
free_sample(sample);
intel->nsamples--;
}
#ifdef CL_THREAD_SAFE
err = pthread_mutex_unlock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_remove_sample: unlocking mutex failed (err: %d): %s\n", err, strerror(err));
}
#endif
}
void clamav_stats_add_sample(const char *virname, const unsigned char *md5, size_t size, stats_section_t *sections, void *cbdata)
{
cli_intel_t *intel;
cli_flagged_sample_t *sample;
size_t i;
char **p;
int err, submit=0;
if (!(cbdata))
return;
intel = (cli_intel_t *)cbdata;
if (!(intel->engine))
return;
if (intel->engine->dconf->stats & DCONF_STATS_DISABLED)
return;
/* First check if we need to submit stats based on memory/number limits */
if ((intel->engine->cb_stats_get_size))
submit = (intel->engine->cb_stats_get_size(cbdata) >= intel->maxmem);
else
submit = (clamav_stats_get_size(cbdata) >= intel->maxmem);
if (submit == 0) {
if ((intel->engine->cb_stats_get_num))
submit = (intel->engine->cb_stats_get_num(cbdata) >= intel->maxsamples);
else
submit = (clamav_stats_get_num(cbdata) >= intel->maxsamples);
}
if (submit) {
if ((intel->engine->cb_stats_submit)) {
intel->engine->cb_stats_submit(intel->engine, cbdata);
} else {
if ((intel->engine->cb_stats_flush))
intel->engine->cb_stats_flush(intel->engine, intel);
return;
}
}
#ifdef CL_THREAD_SAFE
err = pthread_mutex_lock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_add_sample: locking mutex failed (err: %d): %s\n", err, strerror(err));
return;
}
#endif
sample = find_sample(intel, virname, md5, size, sections);
if (!(sample)) {
if (!(intel->samples)) {
sample = intel->samples = calloc(1, sizeof(cli_flagged_sample_t));
if (!(sample))
goto end;
} else {
sample = calloc(1, sizeof(cli_flagged_sample_t));
if (!(sample))
goto end;
sample->next = intel->samples;
intel->samples->prev = sample;
intel->samples = sample;
}
if ((sample->virus_name)) {
for (i=0; sample->virus_name[i] != NULL; i++)
;
p = realloc(sample->virus_name, sizeof(char **) * (i + 1));
if (!(p)) {
free(sample->virus_name);
free(sample);
if (sample == intel->samples)
intel->samples = NULL;
goto end;
}
sample->virus_name = p;
} else {
i=0;
sample->virus_name = calloc(1, sizeof(char **));
if (!(sample->virus_name)) {
free(sample);
if (sample == intel->samples)
intel->samples = NULL;
goto end;
}
}
sample->virus_name[i] = strdup((virname != NULL) ? virname : "[unknown]");
if (!(sample->virus_name[i])) {
free(sample->virus_name);
free(sample);
if (sample == intel->samples)
intel->samples = NULL;
goto end;
}
p = realloc(sample->virus_name, sizeof(char **) * (i+2));
if (!(p)) {
free(sample->virus_name);
free(sample);
if (sample == intel->samples)
intel->samples = NULL;
goto end;
}
sample->virus_name = p;
sample->virus_name[i+1] = NULL;
memcpy(sample->md5, md5, sizeof(sample->md5));
sample->size = (uint32_t)size;
intel->nsamples++;
if (sections && sections->nsections && !(sample->sections)) {
/* Copy the section data that has already been allocated. We don't care if calloc fails; just skip copying if it does. */
sample->sections = calloc(1, sizeof(stats_section_t));
if ((sample->sections)) {
sample->sections->sections = calloc(sections->nsections, sizeof(struct cli_section_hash));
if ((sample->sections->sections)) {
memcpy(sample->sections->sections, sections->sections, sections->nsections * sizeof(struct cli_section_hash));
sample->sections->nsections = sections->nsections;
} else {
free(sample->sections);
sample->sections = NULL;
}
}
}
}
sample->hits++;
end:
#ifdef CL_THREAD_SAFE
err = pthread_mutex_unlock(&(intel->mutex));
if (err) {
cli_warnmsg("clamav_stats_add_sample: unlcoking mutex failed (err: %d): %s\n", err, strerror(err));
}
#endif
return;
}
extern t_sample *file_get(char *samplename, const char *sampleroot) {
t_sample* sample;
sample = find_sample(samplename);
// If sample was not in cache, read it from disk asynchronously
if (sample == NULL) {
// Initialize mutexes if needed
if (!mutex_samples_init) {
pthread_mutex_init(&mutex_samples, NULL);
mutex_samples_init = true;
}
SNDFILE *sndfile;
char path[MAXPATHSIZE];
char error[62];
sf_count_t count;
float *items;
SF_INFO *info;
char set[MAXPATHSIZE];
char sep[2];
int set_n = 0;
struct dirent **namelist;
// load it from disk
if (sscanf(samplename, "%[a-z0-9A-Z]%[/:]%d", set, sep, &set_n)) {
int n;
snprintf(path, MAXPATHSIZE -1, "%s/%s", sampleroot, set);
//printf("looking in %s\n", set);
n = scandir(path, &namelist, wav_filter, alphasort);
if (n > 0) {
snprintf(path, MAXPATHSIZE -1,
"%s/%s/%s", sampleroot, set, namelist[set_n % n]->d_name);
while (n--) {
free(namelist[n]);
}
free(namelist);
} else {
snprintf(path, MAXPATHSIZE -1, "%s/%s", sampleroot, samplename);
}
} else {
snprintf(path, MAXPATHSIZE -1, "%s/%s", sampleroot, samplename);
}
info = (SF_INFO *) calloc(1, sizeof(SF_INFO));
printf("opening %s.\n", path);
if ((sndfile = (SNDFILE *) sf_open(path, SFM_READ, info)) == NULL) {
printf("nope.\n");
free(info);
} else {
items = (float *) calloc(1, sizeof(float) * info->frames * info->channels);
//snprintf(error, (size_t) 61, "hm: %d\n", sf_error(sndfile));
//perror(error);
count = sf_read_float(sndfile, items, info->frames * info->channels);
snprintf(error, (size_t) 61, "count: %d frames: %d channels: %d\n", (int) count, (int) info->frames, info->channels);
perror(error);
if (count == info->frames * info->channels) {
sample = (t_sample *) calloc(1, sizeof(t_sample));
strncpy(sample->name, samplename, MAXPATHSIZE - 1);
sample->info = info;
sample->items = items;
} else {
snprintf(error, (size_t) 61, "didn't get the right number of items: %d vs %d %d\n", (int) count, (int) info->frames * info->channels, sf_error(sndfile));
perror(error);
free(info);
free(items);
}
sf_close(sndfile);
}
if (sample == NULL) {
printf("failed.\n");
} else {
fix_samplerate(sample);
sample->onsets = NULL;
//sample->onsets = segment_get_onsets(sample);
}
// If sample was succesfully read, load it into cache
if (sample) {
pthread_mutex_lock(&mutex_samples);
samples[sample_count++] = sample;
pthread_mutex_unlock(&mutex_samples);
}
}
return(sample);
}
extern t_sample *file_get_from_cache(char *samplename) {
return find_sample(samplename);
}
int main(int argc, char *argv[])
{
int c, i, n, ret, res;
int tid, pos, *n_plp;
cmdopt_t o;
bam_mplp_t mplp;
const bam_pileup1_t **plp;
aux_t **data;
bam_hdr_t *h = 0;
sv_t sv1;
qual_sum_t qual2;
khiter_t k_iter;
khash_t(sv_hash) *sv_h = kh_init(sv_hash);
khash_t(sv_geno) *geno_h = kh_init(sv_geno);
khash_t(colmap) *smp_cols;
khash_t(ped) *ped_h = 0;
mempool_t *mp;
char **samples;
o.min_q = 40; o.min_s = 80; o.min_len = 150; o.min_dp = 10; o.bed = 0, o.fnped = 0, o.mi_prob=0.005;
while ((c = getopt(argc, argv, "hq:s:l:d:b:p:m:")) >= 0) {
if (c == 'h') { usage(stderr, &o); return 0; }
else if (c == 'q') o.min_q = atoi(optarg);
else if (c == 's') o.min_s = atoi(optarg);
else if (c == 'l') o.min_len = atoi(optarg);
else if (c == 'd') o.min_dp = atoi(optarg);
else if (c == 'p') o.fnped = optarg;
else if (c == 'm') o.mi_prob = atof(optarg);
else if (c == 'b') {
if ((o.bed = bed_read(optarg)) == NULL) {
return -1;
}
}
}
if (o.mi_prob < 0.0000000000001 || o.mi_prob > 0.1) {
fprintf(stderr, "Error. Probability of a mendelian inconsistency must be between 0.1 and 0.0000000000001.\n");
}
if (argc - optind < 1) {
usage(stderr, &o);
return 1;
}
// Open files and initalize aux data //
n = argc - optind;
data = calloc(n, sizeof(aux_t*));
samples = (char**)malloc(n * sizeof(char*));
for (i = 0; i < n; ++i) {
data[i] = calloc(1, sizeof (aux_t));
data[i]->fp = sam_open(argv[optind + i], "r");
if (!data[i]->fp) {
fprintf(stderr, "Input file \"%s\" could not be opened.\n", argv[optind + 1]);
return 1;
}
data[i]->min_mapq = o.min_q;
data[i]->min_as = o.min_s;
data[i]->min_len = o.min_len;
data[i]->hdr = sam_hdr_read(data[i]->fp);
if (!data[i]->hdr) {
fprintf(stderr, "Could not read the header for input file \"%s\".\n", argv[optind + 1]);
return 1;
}
samples[i] = find_sample(data[i]->hdr, &res);
if (!samples[i]) {
fprintf(stderr, "Warning. No sample name detected for bam %s. Using filename\n", argv[optind + i]);
samples[i] = argv[optind + i];
}
}
h = data[0]->hdr;
smp_cols = map_samples(samples, n);
if (o.fnped) {
if ((ped_h = read_ped(o.fnped, smp_cols)) == 0) { return -1; }
}
// The core data processing loop //
mplp = bam_mplp_init(n, read_bam, (void**)data);
n_plp = calloc(n, sizeof(int)); // n_plp[i] is the number of covering reads from the i-th BAM
plp = calloc(n, sizeof(bam_pileup1_t*)); // plp[i] points to the array of covering reads in mplp
//quals = (qual_vec_t*)calloc(n, sizeof(qual_vec_t));
mp = mp_init();
while ((ret = bam_mplp_auto(mplp, &tid, &pos, n_plp, plp)) > 0) { // iterate of positions with coverage
int n_sv;
if (o.bed && tid >= 0 && !bed_overlap(o.bed, h->target_name[tid], pos, pos+1)) continue;
n_sv = plp2sv(h, tid, pos, n, n_plp, plp, sv_h);
if (n_sv > 1) { fprintf(stderr, "Warning: more than two alleles detected at %s:%d\n", h->target_name[tid], pos); }
if (n_sv) {
fprintf(stderr, "SV detected at %d:%d\n", tid, pos);
for (k_iter = kh_begin(sv_h); k_iter != kh_end(sv_h); ++k_iter) {
if (kh_exist(sv_h, k_iter)) {
sv1 = kh_value(sv_h, k_iter);
fprintf(stderr, "SV tid1=%d, tid2=%d, pos1=%d, pos2=%d, ori1=%d, ori2=%d, allele=%d\n", sv1.tid1, sv1.tid2, sv1.pos1, sv1.pos2, sv1.ori1, sv1.ori2, sv1.allele);
}
}
res = get_qual_data(h, tid, pos, n, n_plp, plp, n_sv + 1, sv_h, geno_h, mp);
if (res < 0) {
fprintf(stderr, "Error collecting quality data from reads\n");
return -1;
}
kh_clear(sv_hash, sv_h);
}
}
print_header(h, optind, n, argv);
genotype_sv(h, n, geno_h, o.min_dp, ped_h, o.mi_prob);
free(n_plp);
free(plp);
bam_mplp_destroy(mplp);
mp_destroy(mp);
if (o.bed) bed_destroy(o.bed);
for (i = 0; i < n; ++i) {
bam_hdr_destroy(data[i]->hdr);
sam_close(data[i]->fp);
free(data[i]);
free(samples[i]);
}
free(data);
free(samples);
kh_destroy(sv_hash, sv_h);
kh_destroy(sv_geno, geno_h);
kh_destroy(colmap, smp_cols);
kh_destroy(ped, ped_h);
return 0;
}
