} pair64_t;
#define pair64_lt(a,b) ((a).u < (b).u)
-KSORT_INIT(off, pair64_t, pair64_lt)
+KSORT_INIT(offt, pair64_t, pair64_lt)
typedef struct {
uint32_t m, n;
int tid, beg, end, n_off, i, finished;
uint64_t curr_off;
kstring_t str;
- BGZF *fp;
const ti_index_t *idx;
pair64_t *off;
};
}
} else if ((idx->conf.preset&0xffff) == TI_PRESET_VCF) {
// FIXME: the following is NOT tested and is likely to be buggy
- if (id == 5) { // ALT
- char *t;
- int max = 1;
- for (s = str->s + b; s < str->s + i;) {
- if (s[i] == 'D') {
- long x = strtol(s + 1, &t, 10);
- if (x > max) max = x;
- s = t + 1;
- } else ++s;
+ if (id == 4) {
+ if (b < i) intv->end = intv->beg + (i - b);
+ } else if (id == 8) { // look for "END="
+ int c = str->s[i];
+ str->s[i] = 0;
+ s = strstr(str->s + b, "END=");
+ if (s == str->s + b) s += 4;
+ else if (s) {
+ s = strstr(str->s + b, ";END=");
+ if (s) s += 5;
}
- intv->end = intv->beg + max;
+ if (s) intv->end = strtol(s, &s, 0);
+ str->s[i] = c;
}
}
}
l->list[l->n].u = beg; l->list[l->n++].v = end;
}
-static inline void insert_offset2(ti_lidx_t *index2, int _beg, int _end, uint64_t offset)
+static inline uint64_t insert_offset2(ti_lidx_t *index2, int _beg, int _end, uint64_t offset)
{
int i, beg, end;
beg = _beg >> TAD_LIDX_SHIFT;
if (index2->offset[i] == 0) index2->offset[i] = offset;
}
if (index2->n < end + 1) index2->n = end + 1;
+ return (uint64_t)beg<<32 | end;
}
static void merge_chunks(ti_index_t *idx)
ti_index_t *idx;
uint32_t last_bin, save_bin;
int32_t last_coor, last_tid, save_tid;
- uint64_t save_off, last_off, lineno = 0;
+ uint64_t save_off, last_off, lineno = 0, offset0 = (uint64_t)-1, tmp;
kstring_t *str;
str = calloc(1, sizeof(kstring_t));
}
get_intv(idx, str, &intv);
if (last_tid != intv.tid) { // change of chromosomes
+ if (last_tid>intv.tid )
+ {
+ fprintf(stderr,"[ti_index_core] the chromosome blocks not continuous at line %llu, is the file sorted?\n",(unsigned long long)lineno);
+ exit(1);
+ }
last_tid = intv.tid;
last_bin = 0xffffffffu;
} else if (last_coor > intv.beg) {
fprintf(stderr, "[ti_index_core] the file out of order at line %llu\n", (unsigned long long)lineno);
exit(1);
}
- insert_offset2(&idx->index2[intv.tid], intv.beg, intv.end, last_off);
+ tmp = insert_offset2(&idx->index2[intv.tid], intv.beg, intv.end, last_off);
+ if (last_off == 0) offset0 = tmp;
if (intv.bin != last_bin) { // then possibly write the binning index
if (save_bin != 0xffffffffu) // save_bin==0xffffffffu only happens to the first record
insert_offset(idx->index[save_tid], save_bin, save_off, last_off);
if (save_tid >= 0) insert_offset(idx->index[save_tid], save_bin, save_off, bgzf_tell(fp));
merge_chunks(idx);
fill_missing(idx);
+ if (offset0 != (uint64_t)-1 && idx->n && idx->index2[0].offset) {
+ int i, beg = offset0>>32, end = offset0&0xffffffffu;
+ for (i = beg; i <= end; ++i) idx->index2[0].offset[i] = 0;
+ }
free(str->s); free(str);
return idx;
char *fname = get_local_version(fn);
if (fname == 0) return 0;
idx = ti_index_load_local(fname);
+ if (idx == 0) fprintf(stderr, "[ti_index_load] fail to load the index: %s\n", fname);
free(fname);
- if (idx == 0) fprintf(stderr, "[ti_index_load] fail to load BAM index.\n");
return idx;
}
BGZF *fp, *fpidx;
ti_index_t *idx;
if ((fp = bgzf_open(fn, "r")) == 0) {
- fprintf(stderr, "[ti_index_build2] fail to open the BAM file.\n");
+ fprintf(stderr, "[ti_index_build2] fail to open the file: %s\n", fn);
return -1;
}
idx = ti_index_core(fp, conf);
* parse a region in the format chr:beg-end *
********************************************/
-int ti_parse_region(ti_index_t *idx, const char *str, int *tid, int *begin, int *end)
+int ti_get_tid(const ti_index_t *idx, const char *name)
+{
+ khiter_t iter;
+ const khash_t(s) *h = idx->tname;
+ iter = kh_get(s, h, name); /* get the tid */
+ if (iter == kh_end(h)) return -1;
+ return kh_value(h, iter);
+}
+
+int ti_parse_region(const ti_index_t *idx, const char *str, int *tid, int *begin, int *end)
{
char *s, *p;
int i, l, k;
- khiter_t iter;
- khash_t(s) *h = idx->tname;
l = strlen(str);
p = s = (char*)malloc(l+1);
/* squeeze out "," */
s[k] = 0;
for (i = 0; i != k; ++i) if (s[i] == ':') break;
s[i] = 0;
- iter = kh_get(s, h, s); /* get the tid */
- if (iter == kh_end(h)) { // name not found
- *tid = -1; free(s);
+ if ((*tid = ti_get_tid(idx, s)) < 0) {
+ free(s);
return -1;
}
- *tid = kh_value(h, iter);
if (i == k) { /* dump the whole sequence */
*begin = 0; *end = 1<<29; free(s);
return 0;
static inline int reg2bins(uint32_t beg, uint32_t end, uint16_t list[MAX_BIN])
{
int i = 0, k;
+ if (beg >= end) return 0;
+ if (end >= 1u<<29) end = 1u<<29;
--end;
list[i++] = 0;
for (k = 1 + (beg>>26); k <= 1 + (end>>26); ++k) list[i++] = k;
return i;
}
-ti_iter_t ti_first(BGZF *fp)
+ti_iter_t ti_iter_first()
{
ti_iter_t iter;
iter = calloc(1, sizeof(struct __ti_iter_t));
- iter->fp = fp; iter->from_first = 1;
+ iter->from_first = 1;
return iter;
}
-ti_iter_t ti_query(BGZF *fp, const ti_index_t *idx, int tid, int beg, int end)
+ti_iter_t ti_iter_query(const ti_index_t *idx, int tid, int beg, int end)
{
uint16_t *bins;
int i, n_bins, n_off;
uint64_t min_off;
ti_iter_t iter = 0;
+ if (beg < 0) beg = 0;
+ if (end < beg) return 0;
// initialize the iterator
iter = calloc(1, sizeof(struct __ti_iter_t));
- iter->fp = fp; iter->idx = idx;
- iter->tid = tid; iter->beg = beg; iter->end = end; iter->i = -1;
+ iter->idx = idx; iter->tid = tid; iter->beg = beg; iter->end = end; iter->i = -1;
// random access
bins = (uint16_t*)calloc(MAX_BIN, 2);
n_bins = reg2bins(beg, end, bins);
if (p->list[j].v > min_off) off[n_off++] = p->list[j];
}
}
+ if (n_off == 0) {
+ free(bins); free(off); return iter;
+ }
free(bins);
{
int l;
- ks_introsort(off, n_off, off);
+ ks_introsort(offt, n_off, off);
// resolve completely contained adjacent blocks
for (i = 1, l = 0; i < n_off; ++i)
if (off[l].v < off[i].v)
return iter;
}
-const char *ti_iter_read(ti_iter_t iter, int *len)
+const char *ti_iter_read(BGZF *fp, ti_iter_t iter, int *len)
{
if (iter->finished) return 0;
if (iter->from_first) {
int ret;
- if ((ret = ti_readline(iter->fp, &iter->str)) < 0) {
+ if ((ret = ti_readline(fp, &iter->str)) < 0) {
iter->finished = 1;
return 0;
} else {
if (iter->i == iter->n_off - 1) break; // no more chunks
if (iter->i >= 0) assert(iter->curr_off == iter->off[iter->i].v); // otherwise bug
if (iter->i < 0 || iter->off[iter->i].v != iter->off[iter->i+1].u) { // not adjacent chunks; then seek
- bgzf_seek(iter->fp, iter->off[iter->i+1].u, SEEK_SET);
- iter->curr_off = bgzf_tell(iter->fp);
+ bgzf_seek(fp, iter->off[iter->i+1].u, SEEK_SET);
+ iter->curr_off = bgzf_tell(fp);
}
++iter->i;
}
- if ((ret = ti_readline(iter->fp, &iter->str)) >= 0) {
+ if ((ret = ti_readline(fp, &iter->str)) >= 0) {
ti_intv_t intv;
- iter->curr_off = bgzf_tell(iter->fp);
+ iter->curr_off = bgzf_tell(fp);
if (iter->str.s[0] == iter->idx->conf.meta_char) continue;
get_intv((ti_index_t*)iter->idx, &iter->str, &intv);
if (intv.tid != iter->tid || intv.beg >= iter->end) break; // no need to proceed
ti_iter_t iter;
const char *s;
int len;
- iter = ti_query(fp, idx, tid, beg, end);
- while ((s = ti_iter_read(iter, &len)) != 0)
+ iter = ti_iter_query(idx, tid, beg, end);
+ while ((s = ti_iter_read(fp, iter, &len)) != 0)
func(len, s, data);
ti_iter_destroy(iter);
return 0;
}
+
+/*******************
+ * High-level APIs *
+ *******************/
+
+tabix_t *ti_open(const char *fn, const char *fnidx)
+{
+ tabix_t *t;
+ BGZF *fp;
+ if ((fp = bgzf_open(fn, "r")) == 0) return 0;
+ t = calloc(1, sizeof(tabix_t));
+ t->fn = strdup(fn);
+ if (fnidx) t->fnidx = strdup(fnidx);
+ t->fp = fp;
+ return t;
+}
+
+void ti_close(tabix_t *t)
+{
+ if (t) {
+ bgzf_close(t->fp);
+ if (t->idx) ti_index_destroy(t->idx);
+ free(t->fn); free(t->fnidx);
+ free(t);
+ }
+}
+
+int ti_lazy_index_load(tabix_t *t)
+{
+ if (t->idx == 0) { // load index
+ if (t->fnidx) t->idx = ti_index_load_local(t->fnidx);
+ else t->idx = ti_index_load(t->fn);
+ if (t->idx == 0) return -1; // fail to load index
+ }
+ return 0;
+}
+
+ti_iter_t ti_queryi(tabix_t *t, int tid, int beg, int end)
+{
+ if (tid < 0) return ti_iter_first();
+ if (ti_lazy_index_load(t) != 0) return 0;
+ return ti_iter_query(t->idx, tid, beg, end);
+}
+
+ti_iter_t ti_querys(tabix_t *t, const char *reg)
+{
+ int tid, beg, end;
+ if (reg == 0) return ti_iter_first();
+ if (ti_lazy_index_load(t) != 0) return 0;
+ if (ti_parse_region(t->idx, reg, &tid, &beg, &end) < 0) return 0;
+ return ti_iter_query(t->idx, tid, beg, end);
+}
+
+ti_iter_t ti_query(tabix_t *t, const char *name, int beg, int end)
+{
+ int tid;
+ if (name == 0) return ti_iter_first();
+ // then need to load the index
+ if (ti_lazy_index_load(t) != 0) return 0;
+ if ((tid = ti_get_tid(t->idx, name)) < 0) return 0;
+ return ti_iter_query(t->idx, tid, beg, end);
+}
+
+const char *ti_read(tabix_t *t, ti_iter_t iter, int *len)
+{
+ return ti_iter_read(t->fp, iter, len);
+}