X-Git-Url: https://git.donarmstrong.com/?p=samtools.git;a=blobdiff_plain;f=bam2bcf_indel.c;h=9aea5f9d669f79850fb45438fdcf1183c3e1227f;hp=790f59e5e886eed9f1d07b59c816b6188cff71f8;hb=3a1bd4d97b4d58148b5a7fd845a3b6a023eecbed;hpb=3d0fb2fa78f3cafc854fde0a9b5ea56047f2890a diff --git a/bam2bcf_indel.c b/bam2bcf_indel.c index 790f59e..9aea5f9 100644 --- a/bam2bcf_indel.c +++ b/bam2bcf_indel.c @@ -3,15 +3,16 @@ #include #include "bam.h" #include "bam2bcf.h" -#include "ksort.h" #include "kaln.h" #include "kprobaln.h" #include "khash.h" KHASH_SET_INIT_STR(rg) +#include "ksort.h" +KSORT_INIT_GENERIC(uint32_t) + #define MINUS_CONST 0x10000000 #define INDEL_WINDOW_SIZE 50 -#define MIN_SUPPORT_COEF 500 void *bcf_call_add_rg(void *_hash, const char *hdtext, const char *list) { @@ -65,7 +66,7 @@ static int tpos2qpos(const bam1_core_t *c, const uint32_t *cigar, int32_t tpos, for (k = 0; k < c->n_cigar; ++k) { int op = cigar[k] & BAM_CIGAR_MASK; int l = cigar[k] >> BAM_CIGAR_SHIFT; - if (op == BAM_CMATCH) { + if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) { if (c->pos > tpos) return y; if (x + l > tpos) { *_tpos = tpos; @@ -111,10 +112,9 @@ static inline int est_indelreg(int pos, const char *ref, int l, char *ins4) int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_callaux_t *bca, const char *ref, const void *rghash) { - extern void ks_introsort_uint32_t(int, uint32_t*); - int i, s, j, k, t, n_types, *types, max_rd_len, left, right, max_ins, *score1, *score2; + int i, s, j, k, t, n_types, *types, max_rd_len, left, right, max_ins, *score1, *score2, max_ref2; int N, K, l_run, ref_type, n_alt; - char *inscns = 0, *ref2, *query; + char *inscns = 0, *ref2, *query, **ref_sample; khash_t(rg) *hash = (khash_t(rg)*)rghash; if (ref == 0 || bca == 0) return -1; // mark filtered reads @@ -142,31 +142,53 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla if (s == n) return -1; // there is no indel at this position. for (s = N = 0; s < n; ++s) N += n_plp[s]; // N is the total number of reads { // find out how many types of indels are present - int m, n_alt = 0, n_tot = 0; + bca->max_support = bca->max_frac = 0; + int m, n_alt = 0, n_tot = 0, indel_support_ok = 0; uint32_t *aux; aux = calloc(N + 1, 4); m = max_rd_len = 0; aux[m++] = MINUS_CONST; // zero indel is always a type for (s = 0; s < n; ++s) { + int na = 0, nt = 0; for (i = 0; i < n_plp[s]; ++i) { const bam_pileup1_t *p = plp[s] + i; if (rghash == 0 || p->aux == 0) { - ++n_tot; + ++nt; if (p->indel != 0) { - ++n_alt; + ++na; aux[m++] = MINUS_CONST + p->indel; } } j = bam_cigar2qlen(&p->b->core, bam1_cigar(p->b)); if (j > max_rd_len) max_rd_len = j; } + float frac = (float)na/nt; + if ( !indel_support_ok && na >= bca->min_support && frac >= bca->min_frac ) + indel_support_ok = 1; + if ( na > bca->max_support && frac > 0 ) bca->max_support = na, bca->max_frac = frac; + n_alt += na; + n_tot += nt; } + // To prevent long stretches of N's to be mistaken for indels (sometimes thousands of bases), + // check the number of N's in the sequence and skip places where half or more reference bases are Ns. + int nN=0; for (i=pos; i-posi ) { free(aux); return -1; } + ks_introsort(uint32_t, m, aux); // squeeze out identical types for (i = 1, n_types = 1; i < m; ++i) if (aux[i] != aux[i-1]) ++n_types; - if (n_types == 1 || n_alt * MIN_SUPPORT_COEF < n_tot) { // no indels or too few supporting reads - free(aux); return -1; + // Taking totals makes it hard to call rare indels + if ( !bca->per_sample_flt ) + indel_support_ok = ( (float)n_alt / n_tot < bca->min_frac || n_alt < bca->min_support ) ? 0 : 1; + if ( n_types == 1 || !indel_support_ok ) { // then skip + free(aux); return -1; + } + if (n_types >= 64) { + free(aux); + if (bam_verbose >= 2) + fprintf(stderr, "[%s] excessive INDEL alleles at position %d. Skip the position.\n", __func__, pos + 1); + return -1; } types = (int*)calloc(n_types, sizeof(int)); t = 0; @@ -178,7 +200,6 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla for (t = 0; t < n_types; ++t) if (types[t] == 0) break; ref_type = t; // the index of the reference type (0) - assert(n_types < 64); } { // calculate left and right boundary left = pos > INDEL_WINDOW_SIZE? pos - INDEL_WINDOW_SIZE : 0; @@ -189,6 +210,58 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla if (ref[i] == 0) break; right = i; } + /* The following block fixes a long-existing flaw in the INDEL + * calling model: the interference of nearby SNPs. However, it also + * reduces the power because sometimes, substitutions caused by + * indels are not distinguishable from true mutations. Multiple + * sequence realignment helps to increase the power. + */ + { // construct per-sample consensus + int L = right - left + 1, max_i, max2_i; + uint32_t *cns, max, max2; + char *ref0, *r; + ref_sample = calloc(n, sizeof(void*)); + cns = calloc(L, 4); + ref0 = calloc(L, 1); + for (i = 0; i < right - left; ++i) + ref0[i] = bam_nt16_table[(int)ref[i+left]]; + for (s = 0; s < n; ++s) { + r = ref_sample[s] = calloc(L, 1); + memset(cns, 0, sizeof(int) * L); + // collect ref and non-ref counts + for (i = 0; i < n_plp[s]; ++i) { + bam_pileup1_t *p = plp[s] + i; + bam1_t *b = p->b; + uint32_t *cigar = bam1_cigar(b); + uint8_t *seq = bam1_seq(b); + int x = b->core.pos, y = 0; + for (k = 0; k < b->core.n_cigar; ++k) { + int op = cigar[k]&0xf; + int j, l = cigar[k]>>4; + if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) { + for (j = 0; j < l; ++j) + if (x + j >= left && x + j < right) + cns[x+j-left] += (bam1_seqi(seq, y+j) == ref0[x+j-left])? 1 : 0x10000; + x += l; y += l; + } else if (op == BAM_CDEL || op == BAM_CREF_SKIP) x += l; + else if (op == BAM_CINS || op == BAM_CSOFT_CLIP) y += l; + } + } + // determine the consensus + for (i = 0; i < right - left; ++i) r[i] = ref0[i]; + max = max2 = 0; max_i = max2_i = -1; + for (i = 0; i < right - left; ++i) { + if (cns[i]>>16 >= max>>16) max2 = max, max2_i = max_i, max = cns[i], max_i = i; + else if (cns[i]>>16 >= max2>>16) max2 = cns[i], max2_i = i; + } + if ((double)(max&0xffff) / ((max&0xffff) + (max>>16)) >= 0.7) max_i = -1; + if ((double)(max2&0xffff) / ((max2&0xffff) + (max2>>16)) >= 0.7) max2_i = -1; + if (max_i >= 0) r[max_i] = 15; + if (max2_i >= 0) r[max2_i] = 15; +// for (i = 0; i < right - left; ++i) fputc("=ACMGRSVTWYHKDBN"[(int)r[i]], stderr); fputc('\n', stderr); + } + free(ref0); free(cns); + } { // the length of the homopolymer run around the current position int c = bam_nt16_table[(int)ref[pos + 1]]; if (c == 15) l_run = 1; @@ -236,7 +309,8 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla free(inscns_aux); } // compute the likelihood given each type of indel for each read - ref2 = calloc(right - left + max_ins + 2, 1); + max_ref2 = right - left + 2 + 2 * (max_ins > -types[0]? max_ins : -types[0]); + ref2 = calloc(max_ref2, 1); query = calloc(right - left + max_rd_len + max_ins + 2, 1); score1 = calloc(N * n_types, sizeof(int)); score2 = calloc(N * n_types, sizeof(int)); @@ -251,26 +325,29 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla else ir = est_indelreg(pos, ref, -types[t], 0); if (ir > bca->indelreg) bca->indelreg = ir; // fprintf(stderr, "%d, %d, %d\n", pos, types[t], ir); - // write ref2 - for (k = 0, j = left; j <= pos; ++j) - ref2[k++] = bam_nt16_nt4_table[bam_nt16_table[(int)ref[j]]]; - if (types[t] <= 0) j += -types[t]; - else for (l = 0; l < types[t]; ++l) - ref2[k++] = inscns[t*max_ins + l]; - if (types[0] < 0) { // mask deleted sequences to avoid a particular error in the model. - int jj, tmp = types[t] >= 0? -types[0] : -types[0] + types[t]; - for (jj = 0; jj < tmp && j < right && ref[j]; ++jj, ++j) - ref2[k++] = 4; - } - for (; j < right && ref[j]; ++j) - ref2[k++] = bam_nt16_nt4_table[bam_nt16_table[(int)ref[j]]]; - if (j < right) right = j; - // align each read to ref2 + // realignment for (s = K = 0; s < n; ++s) { + // write ref2 + for (k = 0, j = left; j <= pos; ++j) + ref2[k++] = bam_nt16_nt4_table[(int)ref_sample[s][j-left]]; + if (types[t] <= 0) j += -types[t]; + else for (l = 0; l < types[t]; ++l) + ref2[k++] = inscns[t*max_ins + l]; + for (; j < right && ref[j]; ++j) + ref2[k++] = bam_nt16_nt4_table[(int)ref_sample[s][j-left]]; + for (; k < max_ref2; ++k) ref2[k] = 4; + if (j < right) right = j; + // align each read to ref2 for (i = 0; i < n_plp[s]; ++i, ++K) { bam_pileup1_t *p = plp[s] + i; - int qbeg, qend, tbeg, tend, sc; + int qbeg, qend, tbeg, tend, sc, kk; uint8_t *seq = bam1_seq(p->b); + uint32_t *cigar = bam1_cigar(p->b); + if (p->b->core.flag&4) continue; // unmapped reads + // FIXME: the following loop should be better moved outside; nonetheless, realignment should be much slower anyway. + for (kk = 0; kk < p->b->core.n_cigar; ++kk) + if ((cigar[kk]&BAM_CIGAR_MASK) == BAM_CREF_SKIP) break; + if (kk < p->b->core.n_cigar) continue; // FIXME: the following skips soft clips, but using them may be more sensitive. // determine the start and end of sequences for alignment qbeg = tpos2qpos(&p->b->core, bam1_cigar(p->b), left, 0, &tbeg); @@ -365,9 +442,11 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla indelQ2 = tmp > 111? 0 : (int)((1. - tmp/111.) * indelQ2 + .499); // pick the smaller between indelQ1 and indelQ2 indelQ = indelQ1 < indelQ2? indelQ1 : indelQ2; - p->aux = (sc[0]&0x3f)<<16 | seqQ<<8 | indelQ; + if (indelQ > 255) indelQ = 255; + if (seqQ > 255) seqQ = 255; + p->aux = (sc[0]&0x3f)<<16 | seqQ<<8 | indelQ; // use 22 bits in total sumq[sc[0]&0x3f] += indelQ < seqQ? indelQ : seqQ; -// fprintf(stderr, "pos=%d read=%d:%d name=%s call=%d q=%d\n", pos, s, i, bam1_qname(p->b), types[sc[0]&0x3f], indelQ); +// fprintf(stderr, "pos=%d read=%d:%d name=%s call=%d indelQ=%d seqQ=%d\n", pos, s, i, bam1_qname(p->b), types[sc[0]&0x3f], indelQ, seqQ); } } // determine bca->indel_types[] and bca->inscns @@ -405,262 +484,8 @@ int bcf_call_gap_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_calla } free(score1); free(score2); // free + for (i = 0; i < n; ++i) free(ref_sample[i]); + free(ref_sample); free(types); free(inscns); return n_alt > 0? 0 : -1; } - -#define END_SKIP 4 // must be larger than B2B_MAX_MNP -#define MIN_MNP_FLANK_BAQ 20 - -// the following routine is modified from bcf_call_gap_prep() -int bcf_call_mnp_prep(int n, int *n_plp, bam_pileup1_t **plp, int pos, bcf_callaux_t *bca, const char *ref) -{ - extern void ks_introsort_uint32_t(int, uint32_t*); - int i, s, j, k, t, n_types, *types, max_rd_len, left, right, *score1; - int N, K, ref_seq, ref_type, n_alt; - char *ref2, *query; - uint8_t *_seqQ; - if (ref == 0 || bca == 0) return -1; - if (pos < bca->last_mnp_pos + B2B_MNP_WIN) return -2; // to avoid calling a TNP multiple times - if (pos < END_SKIP || ref[pos] == 0 || ref[pos+1] == 0) return -2; // end of the reference - { // determine if there is an MNP - int r[2]; - uint8_t *tt; - r[0] = bam_nt16_table[(int)ref[pos]]; - r[1] = bam_nt16_table[(int)ref[pos+1]]; - for (s = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i) { - bam_pileup1_t *p = plp[s] + i; - int left, rght; - if (p->qpos < END_SKIP || p->qpos >= p->b->core.l_qseq - END_SKIP) continue; - tt = bam1_seq(p->b); - if (bam1_seqi(tt, p->qpos) == r[0] || bam1_seqi(tt, p->qpos+1) == r[1]) continue; // no MNP - tt = bam1_qual(p->b); - for (left = 0, k = p->qpos - END_SKIP; k <= p->qpos; ++k) - left = left > tt[k]? left : tt[k]; - for (rght = 0, k = p->qpos; k < p->b->core.l_qseq - END_SKIP; ++k) - rght = rght > tt[k]? left : tt[k]; - if (left >= MIN_MNP_FLANK_BAQ && rght >= MIN_MNP_FLANK_BAQ) break; // bracketed by good bases - } - if (i != n_plp[s]) break; - } - if (s == n) return -1; // there is no MNP at this position. - } - for (s = N = 0; s < n; ++s) N += n_plp[s]; // N is the total number of reads - { // construct the MNP consensus - uint8_t *tt; - uint32_t *aux, x, *cnt; - int m; - m = max_rd_len = 0; - aux = calloc(N + 1, 4); - for (i = 0, x = 0; i < B2B_MAX_MNP; ++i) - x |= bam_nt16_nt4_table[bam_nt16_table[(int)ref[pos+i]]] << 2*i; - ref_seq = aux[m++] = x; - bca->indelreg = 0; - for (s = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i) { - bam_pileup1_t *p = plp[s] + i; - int stop; - j = bam_cigar2qlen(&p->b->core, bam1_cigar(p->b)); - if (j > max_rd_len) max_rd_len = j; - if (p->qpos < END_SKIP || p->qpos >= p->b->core.l_qseq - END_SKIP) continue; - tt = bam1_seq(p->b); - for (k = j = stop = 0, x = 0; k < B2B_MAX_MNP; ++k) { - int c = bam_nt16_nt4_table[bam1_seqi(tt, p->qpos + k)]; - if (c > 3) break; - if (c != (ref_seq>>k*2&3) && !stop) ++j; - else stop = 1; - x |= c << 2*k; - } -// fprintf(stderr, "* %d, %d\n", x, j); - if (k == B2B_MAX_MNP && j >= 2) aux[m++] = x; - } - } - ks_introsort(uint32_t, m, aux); - // squeeze out indentical types - for (i = 1, n_types = 1; i < m; ++i) - if (aux[i] != aux[i-1]) ++n_types; - if (n_types == 1) { // no indels - free(aux); return -1; - } - // count reads for each type - cnt = alloca(n_types * 4); - cnt[0] = 1<<8 | aux[0]; - for (i = 1, t = 0; i < m; ++i) { - if (aux[i] != aux[i-1]) { - ++t; - cnt[t] = 1<<8 | aux[i]; - } else cnt[t] += 1<<8; - } - free(aux); - // collect types - ks_introsort(uint32_t, n_types, cnt); - for (t = 0; t < n_types; ++t) - if ((cnt[t]&0xff) == ref_seq) break; - if (t == n_types - 1) --t; // we get at least two types - types = (int*)calloc(n_types, sizeof(int)); - for (i = 0; t < n_types; ++i, ++t) types[i] = cnt[t]&0xff; - n_types = i; - // calculate MNP length - for (i = B2B_MAX_MNP - 1, k = 0; i >= 0; --i) { - int c = types[0] >> 2*i & 3; - for (t = 1; t < n_types; ++t) - if ((types[t] >> 2*i & 3) != c) break; - if (t == n_types) ++k; - else break; - } - bca->indelreg = B2B_MAX_MNP - k; - x = (1<<2*bca->indelreg) - 1; - for (t = 0; t < n_types; ++t) types[t] &= x; - ref_seq &= x; - for (t = 0; t < n_types; ++t) - if (types[t] == ref_seq) break; - ref_type = t; -// fprintf(stderr, "%d, %d, [%x,%x] %d\n", pos, n_types, types[0], types[1], bca->indelreg); - } - { // calculate left and right boundary - left = pos > INDEL_WINDOW_SIZE? pos - INDEL_WINDOW_SIZE : 0; - right = pos + INDEL_WINDOW_SIZE; - // in case the alignments stand out the reference - for (i = pos; i < right; ++i) - if (ref[i] == 0) break; - right = i; - } - { // find the highest base quality - _seqQ = calloc(N, 1); - for (s = K = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i, ++K) { - bam_pileup1_t *p = plp[s] + i; - uint8_t *qq, *bq; - int max = 0; - qq = bam1_qual(p->b); - bq = (uint8_t*)bam_aux_get(p->b, "ZQ"); - if (bq) ++bq; - for (j = p->qpos; j < p->b->core.l_qseq && j < p->qpos + bca->indelreg; ++j) { - int q = bq? qq[j] + (bq[j] - 64) : qq[j]; - max = max > q? max : q; - } - _seqQ[K] = max; - } - } - } - // compute the likelihood given each type of indel for each read - ref2 = calloc(right - left + 2, 1); - query = calloc(right - left + max_rd_len + 2, 1); - score1 = calloc(N * n_types, sizeof(int)); - for (t = 0; t < n_types; ++t) { - int l; - kpa_par_t apf1 = { 1e-4, 1e-2, 10 }; - apf1.bw = abs(types[t]) + 3; - // write ref2 - for (k = 0, j = left; j < pos; ++j) - ref2[k++] = bam_nt16_nt4_table[bam_nt16_table[(int)ref[j]]]; - for (i = 0; i < bca->indelreg; ++i, ++j) - ref2[k++] = types[t]>>2*i&3; - for (; j < right && ref[j]; ++j) - ref2[k++] = bam_nt16_nt4_table[bam_nt16_table[(int)ref[j]]]; - if (j < right) right = j; - // align each read to ref2 - for (s = K = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i, ++K) { - bam_pileup1_t *p = plp[s] + i; - int qbeg, qend, tbeg, tend, sc; - uint8_t *seq = bam1_seq(p->b); - // determine the start and end of sequences for alignment - qbeg = tpos2qpos(&p->b->core, bam1_cigar(p->b), left, 0, &tbeg); - qend = tpos2qpos(&p->b->core, bam1_cigar(p->b), right, 1, &tend); - // write the query sequence - for (l = qbeg; l < qend; ++l) - query[l - qbeg] = bam_nt16_nt4_table[bam1_seqi(seq, l)]; - { // do realignment; this is the bottleneck - const uint8_t *qual = bam1_qual(p->b), *bq; - uint8_t *qq; - qq = calloc(qend - qbeg, 1); - bq = (uint8_t*)bam_aux_get(p->b, "ZQ"); - if (bq) ++bq; // skip type - for (l = qbeg; l < qend; ++l) { - qq[l - qbeg] = bq? qual[l] + (bq[l] - 64) : qual[l]; - if (qq[l - qbeg] > 30) qq[l - qbeg] = 30; - if (qq[l - qbeg] < 7) qq[l - qbeg] = 7; - } - sc = kpa_glocal((uint8_t*)ref2 + tbeg - left, tend - tbeg, - (uint8_t*)query, qend - qbeg, qq, &apf1, 0, 0); - l = (int)(100. * sc / (qend - qbeg) + .499); // used for adjusting indelQ below - if (l > 255) l = 255; - score1[K*n_types + t] = sc<<8 | l; - free(qq); - } -/* - for (l = 0; l < tend - tbeg; ++l) - fputc("ACGTN"[(int)ref2[tbeg-left+l]], stderr); - fputc('\n', stderr); - for (l = 0; l < qend - qbeg; ++l) fputc("ACGTN"[(int)query[l]], stderr); - fputc('\n', stderr); - fprintf(stderr, "pos=%d type=%d read=%d:%d name=%s qbeg=%d tbeg=%d score=%d\n", pos, types[t], s, i, bam1_qname(p->b), qbeg, tbeg, sc); -*/ - } - } - } - free(ref2); free(query); - { // compute indelQ - int *sc, tmp, *sumq; - sc = alloca(n_types * sizeof(int)); - sumq = alloca(n_types * sizeof(int)); - memset(sumq, 0, sizeof(int) * n_types); - for (s = K = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i, ++K) { - bam_pileup1_t *p = plp[s] + i; - int *sct = &score1[K*n_types], seqQ, indelQ; - for (t = 0; t < n_types; ++t) sc[t] = sct[t]<<6 | t; - for (t = 1; t < n_types; ++t) // insertion sort - for (j = t; j > 0 && sc[j] < sc[j-1]; --j) - tmp = sc[j], sc[j] = sc[j-1], sc[j-1] = tmp; - if ((sc[0]&0x3f) == ref_type) { - indelQ = (sc[1]>>14) - (sc[0]>>14); - } else { - for (t = 0; t < n_types; ++t) // look for the reference type - if ((sc[t]&0x3f) == ref_type) break; - indelQ = (sc[t]>>14) - (sc[0]>>14); - } - seqQ = _seqQ[K]; - tmp = sc[0]>>6 & 0xff; - indelQ = tmp > 111? 0 : (int)((1. - tmp/111.) * indelQ + .499); // reduce indelQ - if (indelQ > seqQ) indelQ = seqQ; // this is different from indel calling! - p->aux = (sc[0]&0x3f)<<16 | seqQ<<8 | indelQ; - sumq[sc[0]&0x3f] += indelQ < seqQ? indelQ : seqQ; - } - } - // determine bca->indel_types[] and bca->inscns - for (t = 0; t < n_types; ++t) - sumq[t] = sumq[t]<<6 | t; - for (t = 1; t < n_types; ++t) // insertion sort - for (j = t; j > 0 && sumq[j] > sumq[j-1]; --j) - tmp = sumq[j], sumq[j] = sumq[j-1], sumq[j-1] = tmp; - for (t = 0; t < n_types; ++t) // look for the reference type - if ((sumq[t]&0x3f) == ref_type) break; - if (t) { // then move the reference type to the first - tmp = sumq[t]; - for (; t > 0; --t) sumq[t] = sumq[t-1]; - sumq[0] = tmp; - } - for (t = 0; t < 4; ++t) bca->indel_types[t] = B2B_INDEL_NULL; - for (t = 0; t < 4 && t < n_types; ++t) - bca->indel_types[t] = types[sumq[t]&0x3f]; - // update p->aux - for (s = n_alt = 0; s < n; ++s) { - for (i = 0; i < n_plp[s]; ++i) { - bam_pileup1_t *p = plp[s] + i; - int x = types[p->aux>>16&0x3f]; - for (j = 0; j < 4; ++j) - if (x == bca->indel_types[j]) break; - p->aux = j<<16 | (j == 4? 0 : (p->aux&0xffff)); - if ((p->aux>>16&0x3f) > 0) ++n_alt; -// fprintf(stderr, "X pos=%d read=%d:%d name=%s call=%d type=%d q=%d seqQ=%d\n", pos, s, i, bam1_qname(p->b), p->aux>>16&63, bca->indel_types[p->aux>>16&63], p->aux&0xff, p->aux>>8&0xff); - } - } - } - free(score1); - // free - free(types); free(_seqQ); - return n_alt > 0? 0 : -1; -}