tabix/index.c.pysam.c

   1 #include "pysam.h"
   2
   3 #include <ctype.h>
   4 #include <assert.h>
   5 #include <sys/stat.h>
   6 #include "khash.h"
   7 #include "ksort.h"
   8 #include "kstring.h"
   9 #include "bam_endian.h"
  10 #ifdef _USE_KNETFILE
  11 #include "knetfile.h"
  12 #endif
  13 #include "tabix.h"
  14
  15 #define TAD_MIN_CHUNK_GAP 32768
  16 // 1<<14 is the size of minimum bin.
  17 #define TAD_LIDX_SHIFT    14
  18
  19 typedef struct {
  20         uint64_t u, v;
  21 } pair64_t;
  22
  23 #define pair64_lt(a,b) ((a).u < (b).u)
  24 KSORT_INIT(offt, pair64_t, pair64_lt)
  25
  26 typedef struct {
  27         uint32_t m, n;
  28         pair64_t *list;
  29 } ti_binlist_t;
  30
  31 typedef struct {
  32         int32_t n, m;
  33         uint64_t *offset;
  34 } ti_lidx_t;
  35
  36 KHASH_MAP_INIT_INT(i, ti_binlist_t)
  37 KHASH_MAP_INIT_STR(s, int)
  38
  39 struct __ti_index_t {
  40         ti_conf_t conf;
  41         int32_t n, max;
  42         khash_t(s) *tname;
  43         khash_t(i) **index;
  44         ti_lidx_t *index2;
  45 };
  46
  47 struct __ti_iter_t {
  48         int from_first; // read from the first record; no random access
  49         int tid, beg, end, n_off, i, finished;
  50         uint64_t curr_off;
  51         kstring_t str;
  52         const ti_index_t *idx;
  53         pair64_t *off;
  54 };
  55
  56 typedef struct {
  57         int tid, beg, end, bin;
  58 } ti_intv_t;
  59
  60 ti_conf_t ti_conf_gff = { 0, 1, 4, 5, '#', 0 };
  61 ti_conf_t ti_conf_bed = { TI_FLAG_UCSC, 1, 2, 3, '#', 0 };
  62 ti_conf_t ti_conf_psltbl = { TI_FLAG_UCSC, 15, 17, 18, '#', 0 };
  63 ti_conf_t ti_conf_sam = { TI_PRESET_SAM, 3, 4, 0, '@', 0 };
  64 ti_conf_t ti_conf_vcf = { TI_PRESET_VCF, 1, 2, 0, '#', 0 };
  65
  66 /***************
  67  * read a line *
  68  ***************/
  69
  70 /*
  71 int ti_readline(BGZF *fp, kstring_t *str)
  72 {
  73         int c, l = 0;
  74         str->l = 0;
  75         while ((c = bgzf_getc(fp)) >= 0 && c != '\n') {
  76                 ++l;
  77                 if (c != '\r') kputc(c, str);
  78         }
  79         if (c < 0 && l == 0) return -1; // end of file
  80         return str->l;
  81 }
  82 */
  83
  84 /* Below is a faster implementation largely equivalent to the one
  85  * commented out above. */
  86 int ti_readline(BGZF *fp, kstring_t *str)
  87 {
  88         int l, state = 0;
  89         unsigned char *buf = (unsigned char*)fp->uncompressed_block;
  90         str->l = 0;
  91         do {
  92                 if (fp->block_offset >= fp->block_length) {
  93                         if (bgzf_read_block(fp) != 0) { state = -2; break; }
  94                         if (fp->block_length == 0) { state = -1; break; }
  95                 }
  96                 for (l = fp->block_offset; l < fp->block_length && buf[l] != '\n'; ++l);
  97                 if (l < fp->block_length) state = 1;
  98                 l -= fp->block_offset;
  99                 if (str->l + l + 1 >= str->m) {
 100                         str->m = str->l + l + 2;
 101                         kroundup32(str->m);
 102                         str->s = (char*)realloc(str->s, str->m);
 103                 }
 104                 memcpy(str->s + str->l, buf + fp->block_offset, l);
 105                 str->l += l;
 106                 fp->block_offset += l + 1;
 107                 if (fp->block_offset >= fp->block_length) {
 108 #ifdef _USE_KNETFILE
 109                         fp->block_address = knet_tell(fp->x.fpr);
 110 #else
 111                         fp->block_address = ftello(fp->file);
 112 #endif
 113                         fp->block_offset = 0;
 114                         fp->block_length = 0;
 115                 }
 116         } while (state == 0);
 117         if (str->l == 0 && state < 0) return state;
 118         str->s[str->l] = 0;
 119         return str->l;
 120 }
 121
 122 /*************************************
 123  * get the interval from a data line *
 124  *************************************/
 125
 126 static inline int ti_reg2bin(uint32_t beg, uint32_t end)
 127 {
 128         --end;
 129         if (beg>>14 == end>>14) return 4681 + (beg>>14);
 130         if (beg>>17 == end>>17) return  585 + (beg>>17);
 131         if (beg>>20 == end>>20) return   73 + (beg>>20);
 132         if (beg>>23 == end>>23) return    9 + (beg>>23);
 133         if (beg>>26 == end>>26) return    1 + (beg>>26);
 134         return 0;
 135 }
 136
 137 static int get_tid(ti_index_t *idx, const char *ss)
 138 {
 139         khint_t k;
 140         int tid;
 141         k = kh_get(s, idx->tname, ss);
 142         if (k == kh_end(idx->tname)) { // a new target sequence
 143                 int ret, size;
 144                 // update idx->n, ->max, ->index and ->index2
 145                 if (idx->n == idx->max) {
 146                         idx->max = idx->max? idx->max<<1 : 8;
 147                         idx->index = realloc(idx->index, idx->max * sizeof(void*));
 148                         idx->index2 = realloc(idx->index2, idx->max * sizeof(ti_lidx_t));
 149                 }
 150                 memset(&idx->index2[idx->n], 0, sizeof(ti_lidx_t));
 151                 idx->index[idx->n++] = kh_init(i);
 152                 // update ->tname
 153                 tid = size = kh_size(idx->tname);
 154                 k = kh_put(s, idx->tname, strdup(ss), &ret);
 155                 kh_value(idx->tname, k) = size;
 156                 assert(idx->n == kh_size(idx->tname));
 157         } else tid = kh_value(idx->tname, k);
 158         return tid;
 159 }
 160
 161 int ti_get_intv(const ti_conf_t *conf, int len, char *line, ti_interval_t *intv)
 162 {
 163         int i, b = 0, id = 1, ncols = 0;
 164         char *s;
 165         intv->ss = intv->se = 0; intv->beg = intv->end = -1;
 166         for (i = 0; i <= len; ++i) {
 167                 if (line[i] == '\t' || line[i] == 0) {
 168             ++ncols;
 169                         if (id == conf->sc) {
 170                                 intv->ss = line + b; intv->se = line + i;
 171                         } else if (id == conf->bc) {
 172                                 // here ->beg is 0-based.
 173                                 intv->beg = intv->end = strtol(line + b, &s, 0);
 174                                 if (!(conf->preset&TI_FLAG_UCSC)) --intv->beg;
 175                                 else ++intv->end;
 176                                 if (intv->beg < 0) intv->beg = 0;
 177                                 if (intv->end < 1) intv->end = 1;
 178                         } else {
 179                                 if ((conf->preset&0xffff) == TI_PRESET_GENERIC) {
 180                                         if (id == conf->ec) intv->end = strtol(line + b, &s, 0);
 181                                 } else if ((conf->preset&0xffff) == TI_PRESET_SAM) {
 182                                         if (id == 6) { // CIGAR
 183                                                 int l = 0, op;
 184                                                 char *t;
 185                                                 for (s = line + b; s < line + i;) {
 186                                                         long x = strtol(s, &t, 10);
 187                                                         op = toupper(*t);
 188                                                         if (op == 'M' || op == 'D' || op == 'N') l += x;
 189                                                         s = t + 1;
 190                                                 }
 191                                                 if (l == 0) l = 1;
 192                                                 intv->end = intv->beg + l;
 193                                         }
 194                                 } else if ((conf->preset&0xffff) == TI_PRESET_VCF) {
 195                                         // FIXME: the following is NOT tested and is likely to be buggy
 196                                         if (id == 4) {
 197                                                 if (b < i) intv->end = intv->beg + (i - b);
 198                                         } else if (id == 8) { // look for "END="
 199                                                 int c = line[i];
 200                                                 line[i] = 0;
 201                                                 s = strstr(line + b, "END=");
 202                                                 if (s == line + b) s += 4;
 203                                                 else if (s) {
 204                                                         s = strstr(line + b, ";END=");
 205                                                         if (s) s += 5;
 206                                                 }
 207                                                 if (s) intv->end = strtol(s, &s, 0);
 208                                                 line[i] = c;
 209                                         }
 210                                 }
 211                         }
 212                         b = i + 1;
 213                         ++id;
 214                 }
 215         }
 216 /*
 217         if (ncols < conf->sc || ncols < conf->bc || ncols < conf->ec) {
 218                 if (ncols == 1) fprintf(pysamerr,"[get_intv] Is the file tab-delimited? The line has %d field only: %s\n", ncols, line);
 219                 else fprintf(pysamerr,"[get_intv] The line has %d field(s) only: %s\n", ncols, line);
 220                 exit(1);
 221         }
 222 */
 223         if (intv->ss == 0 || intv->se == 0 || intv->beg < 0 || intv->end < 0) return -1;
 224         return 0;
 225 }
 226
 227 static int get_intv(ti_index_t *idx, kstring_t *str, ti_intv_t *intv)
 228 {
 229         ti_interval_t x;
 230         intv->tid = intv->beg = intv->end = intv->bin = -1;
 231         if (ti_get_intv(&idx->conf, str->l, str->s, &x) == 0) {
 232                 int c = *x.se;
 233                 *x.se = '\0'; intv->tid = get_tid(idx, x.ss); *x.se = c;
 234                 intv->beg = x.beg; intv->end = x.end;
 235                 intv->bin = ti_reg2bin(intv->beg, intv->end);
 236                 return (intv->tid >= 0 && intv->beg >= 0 && intv->end >= 0)? 0 : -1;
 237         } else {
 238                 fprintf(pysamerr, "[%s] the following line cannot be parsed and skipped: %s\n", __func__, str->s);
 239                 return -1;
 240         }
 241 }
 242
 243 /************
 244  * indexing *
 245  ************/
 246
 247 // requirement: len <= LEN_MASK
 248 static inline void insert_offset(khash_t(i) *h, int bin, uint64_t beg, uint64_t end)
 249 {
 250         khint_t k;
 251         ti_binlist_t *l;
 252         int ret;
 253         k = kh_put(i, h, bin, &ret);
 254         l = &kh_value(h, k);
 255         if (ret) { // not present
 256                 l->m = 1; l->n = 0;
 257                 l->list = (pair64_t*)calloc(l->m, 16);
 258         }
 259         if (l->n == l->m) {
 260                 l->m <<= 1;
 261                 l->list = (pair64_t*)realloc(l->list, l->m * 16);
 262         }
 263         l->list[l->n].u = beg; l->list[l->n++].v = end;
 264 }
 265
 266 static inline uint64_t insert_offset2(ti_lidx_t *index2, int _beg, int _end, uint64_t offset)
 267 {
 268         int i, beg, end;
 269         beg = _beg >> TAD_LIDX_SHIFT;
 270         end = (_end - 1) >> TAD_LIDX_SHIFT;
 271         if (index2->m < end + 1) {
 272                 int old_m = index2->m;
 273                 index2->m = end + 1;
 274                 kroundup32(index2->m);
 275                 index2->offset = (uint64_t*)realloc(index2->offset, index2->m * 8);
 276                 memset(index2->offset + old_m, 0, 8 * (index2->m - old_m));
 277         }
 278         if (beg == end) {
 279                 if (index2->offset[beg] == 0) index2->offset[beg] = offset;
 280         } else {
 281                 for (i = beg; i <= end; ++i)
 282                         if (index2->offset[i] == 0) index2->offset[i] = offset;
 283         }
 284         if (index2->n < end + 1) index2->n = end + 1;
 285         return (uint64_t)beg<<32 | end;
 286 }
 287
 288 static void merge_chunks(ti_index_t *idx)
 289 {
 290         khash_t(i) *index;
 291         int i, l, m;
 292         khint_t k;
 293         for (i = 0; i < idx->n; ++i) {
 294                 index = idx->index[i];
 295                 for (k = kh_begin(index); k != kh_end(index); ++k) {
 296                         ti_binlist_t *p;
 297                         if (!kh_exist(index, k)) continue;
 298                         p = &kh_value(index, k);
 299                         m = 0;
 300                         for (l = 1; l < p->n; ++l) {
 301                                 if (p->list[m].v>>16 == p->list[l].u>>16) p->list[m].v = p->list[l].v;
 302                                 else p->list[++m] = p->list[l];
 303                         } // ~for(l)
 304                         p->n = m + 1;
 305                 } // ~for(k)
 306         } // ~for(i)
 307 }
 308
 309 static void fill_missing(ti_index_t *idx)
 310 {
 311         int i, j;
 312         for (i = 0; i < idx->n; ++i) {
 313                 ti_lidx_t *idx2 = &idx->index2[i];
 314                 for (j = 1; j < idx2->n; ++j)
 315                         if (idx2->offset[j] == 0)
 316                                 idx2->offset[j] = idx2->offset[j-1];
 317         }
 318 }
 319
 320 ti_index_t *ti_index_core(BGZF *fp, const ti_conf_t *conf)
 321 {
 322         int ret;
 323         ti_index_t *idx;
 324         uint32_t last_bin, save_bin;
 325         int32_t last_coor, last_tid, save_tid;
 326         uint64_t save_off, last_off, lineno = 0, offset0 = (uint64_t)-1, tmp;
 327         kstring_t *str;
 328
 329         str = calloc(1, sizeof(kstring_t));
 330
 331         idx = (ti_index_t*)calloc(1, sizeof(ti_index_t));
 332         idx->conf = *conf;
 333         idx->n = idx->max = 0;
 334         idx->tname = kh_init(s);
 335         idx->index = 0;
 336         idx->index2 = 0;
 337
 338         save_bin = save_tid = last_tid = last_bin = 0xffffffffu;
 339         save_off = last_off = bgzf_tell(fp); last_coor = 0xffffffffu;
 340         while ((ret = ti_readline(fp, str)) >= 0) {
 341                 ti_intv_t intv;
 342                 ++lineno;
 343                 if (lineno <= idx->conf.line_skip || str->s[0] == idx->conf.meta_char) {
 344                         last_off = bgzf_tell(fp);
 345                         continue;
 346                 }
 347                 get_intv(idx, str, &intv);
 348         if ( intv.beg<0 || intv.end<0 )
 349         {
 350             fprintf(pysamerr,"[ti_index_core] the indexes overlap or are out of bounds\n");
 351             exit(1);
 352         }
 353                 if (last_tid != intv.tid) { // change of chromosomes
 354             if (last_tid>intv.tid )
 355             {
 356                 fprintf(pysamerr,"[ti_index_core] the chromosome blocks not continuous at line %llu, is the file sorted? [pos %d]\n",(unsigned long long)lineno,intv.beg+1);
 357                 exit(1);
 358             }
 359                         last_tid = intv.tid;
 360                         last_bin = 0xffffffffu;
 361                 } else if (last_coor > intv.beg) {
 362                         fprintf(pysamerr, "[ti_index_core] the file out of order at line %llu\n", (unsigned long long)lineno);
 363                         exit(1);
 364                 }
 365                 tmp = insert_offset2(&idx->index2[intv.tid], intv.beg, intv.end, last_off);
 366                 if (last_off == 0) offset0 = tmp;
 367                 if (intv.bin != last_bin) { // then possibly write the binning index
 368                         if (save_bin != 0xffffffffu) // save_bin==0xffffffffu only happens to the first record
 369                                 insert_offset(idx->index[save_tid], save_bin, save_off, last_off);
 370                         save_off = last_off;
 371                         save_bin = last_bin = intv.bin;
 372                         save_tid = intv.tid;
 373                         if (save_tid < 0) break;
 374                 }
 375                 if (bgzf_tell(fp) <= last_off) {
 376                         fprintf(pysamerr, "[ti_index_core] bug in BGZF: %llx < %llx\n",
 377                                         (unsigned long long)bgzf_tell(fp), (unsigned long long)last_off);
 378                         exit(1);
 379                 }
 380                 last_off = bgzf_tell(fp);
 381                 last_coor = intv.beg;
 382         }
 383         if (save_tid >= 0) insert_offset(idx->index[save_tid], save_bin, save_off, bgzf_tell(fp));
 384         merge_chunks(idx);
 385         fill_missing(idx);
 386         if (offset0 != (uint64_t)-1 && idx->n && idx->index2[0].offset) {
 387                 int i, beg = offset0>>32, end = offset0&0xffffffffu;
 388                 for (i = beg; i <= end; ++i) idx->index2[0].offset[i] = 0;
 389         }
 390
 391         free(str->s); free(str);
 392         return idx;
 393 }
 394
 395 void ti_index_destroy(ti_index_t *idx)
 396 {
 397         khint_t k;
 398         int i;
 399         if (idx == 0) return;
 400         // destroy the name hash table
 401         for (k = kh_begin(idx->tname); k != kh_end(idx->tname); ++k) {
 402                 if (kh_exist(idx->tname, k))
 403                         free((char*)kh_key(idx->tname, k));
 404         }
 405         kh_destroy(s, idx->tname);
 406         // destroy the binning index
 407         for (i = 0; i < idx->n; ++i) {
 408                 khash_t(i) *index = idx->index[i];
 409                 ti_lidx_t *index2 = idx->index2 + i;
 410                 for (k = kh_begin(index); k != kh_end(index); ++k) {
 411                         if (kh_exist(index, k))
 412                                 free(kh_value(index, k).list);
 413                 }
 414                 kh_destroy(i, index);
 415                 free(index2->offset);
 416         }
 417         free(idx->index);
 418         // destroy the linear index
 419         free(idx->index2);
 420         free(idx);
 421 }
 422
 423 /******************
 424  * index file I/O *
 425  ******************/
 426
 427 void ti_index_save(const ti_index_t *idx, BGZF *fp)
 428 {
 429         int32_t i, size, ti_is_be;
 430         khint_t k;
 431         ti_is_be = bam_is_big_endian();
 432         bgzf_write(fp, "TBI\1", 4);
 433         if (ti_is_be) {
 434                 uint32_t x = idx->n;
 435                 bgzf_write(fp, bam_swap_endian_4p(&x), 4);
 436         } else bgzf_write(fp, &idx->n, 4);
 437         assert(sizeof(ti_conf_t) == 24);
 438         if (ti_is_be) { // write ti_conf_t;
 439                 uint32_t x[6];
 440                 memcpy(x, &idx->conf, 24);
 441                 for (i = 0; i < 6; ++i) bgzf_write(fp, bam_swap_endian_4p(&x[i]), 4);
 442         } else bgzf_write(fp, &idx->conf, sizeof(ti_conf_t));
 443         { // write target names
 444                 char **name;
 445                 int32_t l = 0;
 446                 name = calloc(kh_size(idx->tname), sizeof(void*));
 447                 for (k = kh_begin(idx->tname); k != kh_end(idx->tname); ++k)
 448                         if (kh_exist(idx->tname, k))
 449                                 name[kh_value(idx->tname, k)] = (char*)kh_key(idx->tname, k);
 450                 for (i = 0; i < kh_size(idx->tname); ++i)
 451                         l += strlen(name[i]) + 1;
 452                 if (ti_is_be) bgzf_write(fp, bam_swap_endian_4p(&l), 4);
 453                 else bgzf_write(fp, &l, 4);
 454                 for (i = 0; i < kh_size(idx->tname); ++i)
 455                         bgzf_write(fp, name[i], strlen(name[i]) + 1);
 456                 free(name);
 457         }
 458         for (i = 0; i < idx->n; ++i) {
 459                 khash_t(i) *index = idx->index[i];
 460                 ti_lidx_t *index2 = idx->index2 + i;
 461                 // write binning index
 462                 size = kh_size(index);
 463                 if (ti_is_be) { // big endian
 464                         uint32_t x = size;
 465                         bgzf_write(fp, bam_swap_endian_4p(&x), 4);
 466                 } else bgzf_write(fp, &size, 4);
 467                 for (k = kh_begin(index); k != kh_end(index); ++k) {
 468                         if (kh_exist(index, k)) {
 469                                 ti_binlist_t *p = &kh_value(index, k);
 470                                 if (ti_is_be) { // big endian
 471                                         uint32_t x;
 472                                         x = kh_key(index, k); bgzf_write(fp, bam_swap_endian_4p(&x), 4);
 473                                         x = p->n; bgzf_write(fp, bam_swap_endian_4p(&x), 4);
 474                                         for (x = 0; (int)x < p->n; ++x) {
 475                                                 bam_swap_endian_8p(&p->list[x].u);
 476                                                 bam_swap_endian_8p(&p->list[x].v);
 477                                         }
 478                                         bgzf_write(fp, p->list, 16 * p->n);
 479                                         for (x = 0; (int)x < p->n; ++x) {
 480                                                 bam_swap_endian_8p(&p->list[x].u);
 481                                                 bam_swap_endian_8p(&p->list[x].v);
 482                                         }
 483                                 } else {
 484                                         bgzf_write(fp, &kh_key(index, k), 4);
 485                                         bgzf_write(fp, &p->n, 4);
 486                                         bgzf_write(fp, p->list, 16 * p->n);
 487                                 }
 488                         }
 489                 }
 490                 // write linear index (index2)
 491                 if (ti_is_be) {
 492                         int x = index2->n;
 493                         bgzf_write(fp, bam_swap_endian_4p(&x), 4);
 494                 } else bgzf_write(fp, &index2->n, 4);
 495                 if (ti_is_be) { // big endian
 496                         int x;
 497                         for (x = 0; (int)x < index2->n; ++x)
 498                                 bam_swap_endian_8p(&index2->offset[x]);
 499                         bgzf_write(fp, index2->offset, 8 * index2->n);
 500                         for (x = 0; (int)x < index2->n; ++x)
 501                                 bam_swap_endian_8p(&index2->offset[x]);
 502                 } else bgzf_write(fp, index2->offset, 8 * index2->n);
 503         }
 504 }
 505
 506 static ti_index_t *ti_index_load_core(BGZF *fp)
 507 {
 508         int i, ti_is_be;
 509         char magic[4];
 510         ti_index_t *idx;
 511         ti_is_be = bam_is_big_endian();
 512         if (fp == 0) {
 513                 fprintf(pysamerr, "[ti_index_load_core] fail to load index.\n");
 514                 return 0;
 515         }
 516         bgzf_read(fp, magic, 4);
 517         if (strncmp(magic, "TBI\1", 4)) {
 518                 fprintf(pysamerr, "[ti_index_load] wrong magic number.\n");
 519                 return 0;
 520         }
 521         idx = (ti_index_t*)calloc(1, sizeof(ti_index_t));
 522         bgzf_read(fp, &idx->n, 4);
 523         if (ti_is_be) bam_swap_endian_4p(&idx->n);
 524         idx->tname = kh_init(s);
 525         idx->index = (khash_t(i)**)calloc(idx->n, sizeof(void*));
 526         idx->index2 = (ti_lidx_t*)calloc(idx->n, sizeof(ti_lidx_t));
 527         // read idx->conf
 528         bgzf_read(fp, &idx->conf, sizeof(ti_conf_t));
 529         if (ti_is_be) {
 530                 bam_swap_endian_4p(&idx->conf.preset);
 531                 bam_swap_endian_4p(&idx->conf.sc);
 532                 bam_swap_endian_4p(&idx->conf.bc);
 533                 bam_swap_endian_4p(&idx->conf.ec);
 534                 bam_swap_endian_4p(&idx->conf.meta_char);
 535                 bam_swap_endian_4p(&idx->conf.line_skip);
 536         }
 537         { // read target names
 538                 int j, ret;
 539                 kstring_t *str;
 540                 int32_t l;
 541                 uint8_t *buf;
 542                 bgzf_read(fp, &l, 4);
 543                 if (ti_is_be) bam_swap_endian_4p(&l);
 544                 buf = calloc(l, 1);
 545                 bgzf_read(fp, buf, l);
 546                 str = calloc(1, sizeof(kstring_t));
 547                 for (i = j = 0; i < l; ++i) {
 548                         if (buf[i] == 0) {
 549                                 khint_t k = kh_put(s, idx->tname, strdup(str->s), &ret);
 550                                 kh_value(idx->tname, k) = j++;
 551                                 str->l = 0;
 552                         } else kputc(buf[i], str);
 553                 }
 554                 free(str->s); free(str); free(buf);
 555         }
 556         for (i = 0; i < idx->n; ++i) {
 557                 khash_t(i) *index;
 558                 ti_lidx_t *index2 = idx->index2 + i;
 559                 uint32_t key, size;
 560                 khint_t k;
 561                 int j, ret;
 562                 ti_binlist_t *p;
 563                 index = idx->index[i] = kh_init(i);
 564                 // load binning index
 565                 bgzf_read(fp, &size, 4);
 566                 if (ti_is_be) bam_swap_endian_4p(&size);
 567                 for (j = 0; j < (int)size; ++j) {
 568                         bgzf_read(fp, &key, 4);
 569                         if (ti_is_be) bam_swap_endian_4p(&key);
 570                         k = kh_put(i, index, key, &ret);
 571                         p = &kh_value(index, k);
 572                         bgzf_read(fp, &p->n, 4);
 573                         if (ti_is_be) bam_swap_endian_4p(&p->n);
 574                         p->m = p->n;
 575                         p->list = (pair64_t*)malloc(p->m * 16);
 576                         bgzf_read(fp, p->list, 16 * p->n);
 577                         if (ti_is_be) {
 578                                 int x;
 579                                 for (x = 0; x < p->n; ++x) {
 580                                         bam_swap_endian_8p(&p->list[x].u);
 581                                         bam_swap_endian_8p(&p->list[x].v);
 582                                 }
 583                         }
 584                 }
 585                 // load linear index
 586                 bgzf_read(fp, &index2->n, 4);
 587                 if (ti_is_be) bam_swap_endian_4p(&index2->n);
 588                 index2->m = index2->n;
 589                 index2->offset = (uint64_t*)calloc(index2->m, 8);
 590                 bgzf_read(fp, index2->offset, index2->n * 8);
 591                 if (ti_is_be)
 592                         for (j = 0; j < index2->n; ++j) bam_swap_endian_8p(&index2->offset[j]);
 593         }
 594         return idx;
 595 }
 596
 597 ti_index_t *ti_index_load_local(const char *fnidx)
 598 {
 599         BGZF *fp;
 600         fp = bgzf_open(fnidx, "r");
 601         if (fp) {
 602                 ti_index_t *idx = ti_index_load_core(fp);
 603                 bgzf_close(fp);
 604                 return idx;
 605         } else return 0;
 606 }
 607
 608 #ifdef _USE_KNETFILE
 609 static void download_from_remote(const char *url)
 610 {
 611         const int buf_size = 1 * 1024 * 1024;
 612         char *fn;
 613         FILE *fp;
 614         uint8_t *buf;
 615         knetFile *fp_remote;
 616         int l;
 617         if (strstr(url, "ftp://") != url && strstr(url, "http://") != url) return;
 618         l = strlen(url);
 619         for (fn = (char*)url + l - 1; fn >= url; --fn)
 620                 if (*fn == '/') break;
 621         ++fn; // fn now points to the file name
 622         fp_remote = knet_open(url, "r");
 623         if (fp_remote == 0) {
 624                 fprintf(pysamerr, "[download_from_remote] fail to open remote file.\n");
 625                 return;
 626         }
 627         if ((fp = fopen(fn, "w")) == 0) {
 628                 fprintf(pysamerr, "[download_from_remote] fail to create file in the working directory.\n");
 629                 knet_close(fp_remote);
 630                 return;
 631         }
 632         buf = (uint8_t*)calloc(buf_size, 1);
 633         while ((l = knet_read(fp_remote, buf, buf_size)) != 0)
 634                 fwrite(buf, 1, l, fp);
 635         free(buf);
 636         fclose(fp);
 637         knet_close(fp_remote);
 638 }
 639 #else
 640 static void download_from_remote(const char *url)
 641 {
 642         return;
 643 }
 644 #endif
 645
 646 static char *get_local_version(const char *fn)
 647 {
 648     struct stat sbuf;
 649         char *fnidx = (char*)calloc(strlen(fn) + 5, 1);
 650         strcat(strcpy(fnidx, fn), ".tbi");
 651         if ((strstr(fnidx, "ftp://") == fnidx || strstr(fnidx, "http://") == fnidx)) {
 652                 char *p, *url;
 653                 int l = strlen(fnidx);
 654                 for (p = fnidx + l - 1; p >= fnidx; --p)
 655                         if (*p == '/') break;
 656                 url = fnidx; fnidx = strdup(p + 1);
 657                 if (stat(fnidx, &sbuf) == 0) {
 658                         free(url);
 659                         return fnidx;
 660                 }
 661                 fprintf(pysamerr, "[%s] downloading the index file...\n", __func__);
 662                 download_from_remote(url);
 663                 free(url);
 664         }
 665     if (stat(fnidx, &sbuf) == 0) return fnidx;
 666         free(fnidx); return 0;
 667 }
 668
 669 const char **ti_seqname(const ti_index_t *idx, int *n)
 670 {
 671         const char **names;
 672         khint_t k;
 673         *n = idx->n;
 674         names = calloc(idx->n, sizeof(void*));
 675         for (k = kh_begin(idx->tname); k < kh_end(idx->tname); ++k)
 676                 if (kh_exist(idx->tname, k))
 677                         names[kh_val(idx->tname, k)] = kh_key(idx->tname, k);
 678         return names;
 679 }
 680
 681 ti_index_t *ti_index_load(const char *fn)
 682 {
 683         ti_index_t *idx;
 684     char *fname = get_local_version(fn);
 685         if (fname == 0) return 0;
 686         idx = ti_index_load_local(fname);
 687         if (idx == 0) fprintf(pysamerr, "[ti_index_load] fail to load the index: %s\n", fname);
 688     free(fname);
 689         return idx;
 690 }
 691
 692 int ti_index_build2(const char *fn, const ti_conf_t *conf, const char *_fnidx)
 693 {
 694         char *fnidx;
 695         BGZF *fp, *fpidx;
 696         ti_index_t *idx;
 697         if ((fp = bgzf_open(fn, "r")) == 0) {
 698                 fprintf(pysamerr, "[ti_index_build2] fail to open the file: %s\n", fn);
 699                 return -1;
 700         }
 701         idx = ti_index_core(fp, conf);
 702         bgzf_close(fp);
 703         if (_fnidx == 0) {
 704                 fnidx = (char*)calloc(strlen(fn) + 5, 1);
 705                 strcpy(fnidx, fn); strcat(fnidx, ".tbi");
 706         } else fnidx = strdup(_fnidx);
 707         fpidx = bgzf_open(fnidx, "w");
 708         if (fpidx == 0) {
 709                 fprintf(pysamerr, "[ti_index_build2] fail to create the index file.\n");
 710                 free(fnidx);
 711                 return -1;
 712         }
 713         ti_index_save(idx, fpidx);
 714         ti_index_destroy(idx);
 715         bgzf_close(fpidx);
 716         free(fnidx);
 717         return 0;
 718 }
 719
 720 int ti_index_build(const char *fn, const ti_conf_t *conf)
 721 {
 722         return ti_index_build2(fn, conf, 0);
 723 }
 724
 725 /********************************************
 726  * parse a region in the format chr:beg-end *
 727  ********************************************/
 728
 729 int ti_get_tid(const ti_index_t *idx, const char *name)
 730 {
 731         khiter_t iter;
 732         const khash_t(s) *h = idx->tname;
 733         iter = kh_get(s, h, name); /* get the tid */
 734         if (iter == kh_end(h)) return -1;
 735         return kh_value(h, iter);
 736 }
 737
 738 int ti_parse_region(const ti_index_t *idx, const char *str, int *tid, int *begin, int *end)
 739 {
 740         char *s, *p;
 741         int i, l, k;
 742         l = strlen(str);
 743         p = s = (char*)malloc(l+1);
 744         /* squeeze out "," */
 745         for (i = k = 0; i != l; ++i)
 746                 if (str[i] != ',' && !isspace(str[i])) s[k++] = str[i];
 747         s[k] = 0;
 748         for (i = 0; i != k; ++i) if (s[i] == ':') break;
 749         s[i] = 0;
 750         if ((*tid = ti_get_tid(idx, s)) < 0) {
 751                 free(s);
 752                 return -1;
 753         }
 754         if (i == k) { /* dump the whole sequence */
 755                 *begin = 0; *end = 1<<29; free(s);
 756                 return 0;
 757         }
 758         for (p = s + i + 1; i != k; ++i) if (s[i] == '-') break;
 759         *begin = atoi(p);
 760         if (i < k) {
 761                 p = s + i + 1;
 762                 *end = atoi(p);
 763         } else *end = 1<<29;
 764         if (*begin > 0) --*begin;
 765         free(s);
 766         if (*begin > *end) return -1;
 767         return 0;
 768 }
 769
 770 /*******************************
 771  * retrieve a specified region *
 772  *******************************/
 773
 774 #define MAX_BIN 37450 // =(8^6-1)/7+1
 775
 776 static inline int reg2bins(uint32_t beg, uint32_t end, uint16_t list[MAX_BIN])
 777 {
 778         int i = 0, k;
 779         if (beg >= end) return 0;
 780         if (end >= 1u<<29) end = 1u<<29;
 781         --end;
 782         list[i++] = 0;
 783         for (k =    1 + (beg>>26); k <=    1 + (end>>26); ++k) list[i++] = k;
 784         for (k =    9 + (beg>>23); k <=    9 + (end>>23); ++k) list[i++] = k;
 785         for (k =   73 + (beg>>20); k <=   73 + (end>>20); ++k) list[i++] = k;
 786         for (k =  585 + (beg>>17); k <=  585 + (end>>17); ++k) list[i++] = k;
 787         for (k = 4681 + (beg>>14); k <= 4681 + (end>>14); ++k) list[i++] = k;
 788         return i;
 789 }
 790
 791 ti_iter_t ti_iter_first()
 792 {
 793         ti_iter_t iter;
 794         iter = calloc(1, sizeof(struct __ti_iter_t));
 795         iter->from_first = 1;
 796         return iter;
 797 }
 798
 799 ti_iter_t ti_iter_query(const ti_index_t *idx, int tid, int beg, int end)
 800 {
 801         uint16_t *bins;
 802         int i, n_bins, n_off;
 803         pair64_t *off;
 804         khint_t k;
 805         khash_t(i) *index;
 806         uint64_t min_off;
 807         ti_iter_t iter = 0;
 808
 809         if (beg < 0) beg = 0;
 810         if (end < beg) return 0;
 811         // initialize the iterator
 812         iter = calloc(1, sizeof(struct __ti_iter_t));
 813         iter->idx = idx; iter->tid = tid; iter->beg = beg; iter->end = end; iter->i = -1;
 814         // random access
 815         bins = (uint16_t*)calloc(MAX_BIN, 2);
 816         n_bins = reg2bins(beg, end, bins);
 817         index = idx->index[tid];
 818         if (idx->index2[tid].n > 0) {
 819                 min_off = (beg>>TAD_LIDX_SHIFT >= idx->index2[tid].n)? idx->index2[tid].offset[idx->index2[tid].n-1]
 820                         : idx->index2[tid].offset[beg>>TAD_LIDX_SHIFT];
 821                 if (min_off == 0) { // improvement for index files built by tabix prior to 0.1.4
 822                         int n = beg>>TAD_LIDX_SHIFT;
 823                         if (n > idx->index2[tid].n) n = idx->index2[tid].n;
 824                         for (i = n - 1; i >= 0; --i)
 825                                 if (idx->index2[tid].offset[i] != 0) break;
 826                         if (i >= 0) min_off = idx->index2[tid].offset[i];
 827                 }
 828         } else min_off = 0; // tabix 0.1.2 may produce such index files
 829         for (i = n_off = 0; i < n_bins; ++i) {
 830                 if ((k = kh_get(i, index, bins[i])) != kh_end(index))
 831                         n_off += kh_value(index, k).n;
 832         }
 833         if (n_off == 0) {
 834                 free(bins); return iter;
 835         }
 836         off = (pair64_t*)calloc(n_off, 16);
 837         for (i = n_off = 0; i < n_bins; ++i) {
 838                 if ((k = kh_get(i, index, bins[i])) != kh_end(index)) {
 839                         int j;
 840                         ti_binlist_t *p = &kh_value(index, k);
 841                         for (j = 0; j < p->n; ++j)
 842                                 if (p->list[j].v > min_off) off[n_off++] = p->list[j];
 843                 }
 844         }
 845         if (n_off == 0) {
 846                 free(bins); free(off); return iter;
 847         }
 848         free(bins);
 849         {
 850                 int l;
 851                 ks_introsort(offt, n_off, off);
 852                 // resolve completely contained adjacent blocks
 853                 for (i = 1, l = 0; i < n_off; ++i)
 854                         if (off[l].v < off[i].v)
 855                                 off[++l] = off[i];
 856                 n_off = l + 1;
 857                 // resolve overlaps between adjacent blocks; this may happen due to the merge in indexing
 858                 for (i = 1; i < n_off; ++i)
 859                         if (off[i-1].v >= off[i].u) off[i-1].v = off[i].u;
 860                 { // merge adjacent blocks
 861                         for (i = 1, l = 0; i < n_off; ++i) {
 862                                 if (off[l].v>>16 == off[i].u>>16) off[l].v = off[i].v;
 863                                 else off[++l] = off[i];
 864                         }
 865                         n_off = l + 1;
 866                 }
 867         }
 868         iter->n_off = n_off; iter->off = off;
 869         return iter;
 870 }
 871
 872 const char *ti_iter_read(BGZF *fp, ti_iter_t iter, int *len)
 873 {
 874         if (iter->finished) return 0;
 875         if (iter->from_first) {
 876                 int ret;
 877                 if ((ret = ti_readline(fp, &iter->str)) < 0) {
 878                         iter->finished = 1;
 879                         return 0;
 880                 } else {
 881                         if (len) *len = iter->str.l;
 882                         return iter->str.s;
 883                 }
 884         }
 885         if (iter->n_off == 0) return 0;
 886         while (1) {
 887                 int ret;
 888                 if (iter->curr_off == 0 || iter->curr_off >= iter->off[iter->i].v) { // then jump to the next chunk
 889                         if (iter->i == iter->n_off - 1) break; // no more chunks
 890                         if (iter->i >= 0) assert(iter->curr_off == iter->off[iter->i].v); // otherwise bug
 891                         if (iter->i < 0 || iter->off[iter->i].v != iter->off[iter->i+1].u) { // not adjacent chunks; then seek
 892                                 bgzf_seek(fp, iter->off[iter->i+1].u, SEEK_SET);
 893                                 iter->curr_off = bgzf_tell(fp);
 894                         }
 895                         ++iter->i;
 896                 }
 897                 if ((ret = ti_readline(fp, &iter->str)) >= 0) {
 898                         ti_intv_t intv;
 899                         iter->curr_off = bgzf_tell(fp);
 900                         if (iter->str.s[0] == iter->idx->conf.meta_char) continue;
 901                         get_intv((ti_index_t*)iter->idx, &iter->str, &intv);
 902                         if (intv.tid != iter->tid || intv.beg >= iter->end) break; // no need to proceed
 903                         else if (intv.end > iter->beg && iter->end > intv.beg) {
 904                                 if (len) *len = iter->str.l;
 905                                 return iter->str.s;
 906                         }
 907                 } else break; // end of file
 908         }
 909         iter->finished = 1;
 910         return 0;
 911 }
 912
 913 void ti_iter_destroy(ti_iter_t iter)
 914 {
 915         if (iter) {
 916                 free(iter->str.s); free(iter->off);
 917                 free(iter);
 918         }
 919 }
 920
 921 int ti_fetch(BGZF *fp, const ti_index_t *idx, int tid, int beg, int end, void *data, ti_fetch_f func)
 922 {
 923         ti_iter_t iter;
 924         const char *s;
 925         int len;
 926         iter = ti_iter_query(idx, tid, beg, end);
 927         while ((s = ti_iter_read(fp, iter, &len)) != 0)
 928                 func(len, s, data);
 929         ti_iter_destroy(iter);
 930         return 0;
 931 }
 932
 933 const ti_conf_t *ti_get_conf(ti_index_t *idx) { return idx? &idx->conf : 0; }
 934
 935 /*******************
 936  * High-level APIs *
 937  *******************/
 938
 939 tabix_t *ti_open(const char *fn, const char *fnidx)
 940 {
 941         tabix_t *t;
 942         BGZF *fp;
 943         if ((fp = bgzf_open(fn, "r")) == 0) return 0;
 944         t = calloc(1, sizeof(tabix_t));
 945         t->fn = strdup(fn);
 946         if (fnidx) t->fnidx = strdup(fnidx);
 947         t->fp = fp;
 948         return t;
 949 }
 950
 951 void ti_close(tabix_t *t)
 952 {
 953         if (t) {
 954                 bgzf_close(t->fp);
 955                 if (t->idx) ti_index_destroy(t->idx);
 956                 free(t->fn); free(t->fnidx);
 957                 free(t);
 958         }
 959 }
 960
 961 int ti_lazy_index_load(tabix_t *t)
 962 {
 963         if (t->idx == 0) { // load index
 964                 if (t->fnidx) t->idx = ti_index_load_local(t->fnidx);
 965                 else t->idx = ti_index_load(t->fn);
 966                 if (t->idx == 0) return -1; // fail to load index
 967         }
 968         return 0;
 969 }
 970
 971 ti_iter_t ti_queryi(tabix_t *t, int tid, int beg, int end)
 972 {
 973         if (tid < 0) return ti_iter_first();
 974         if (ti_lazy_index_load(t) != 0) return 0;
 975         return ti_iter_query(t->idx, tid, beg, end);
 976 }
 977
 978 ti_iter_t ti_querys(tabix_t *t, const char *reg)
 979 {
 980         int tid, beg, end;
 981         if (reg == 0) return ti_iter_first();
 982         if (ti_lazy_index_load(t) != 0) return 0;
 983         if (ti_parse_region(t->idx, reg, &tid, &beg, &end) < 0) return 0;
 984         return ti_iter_query(t->idx, tid, beg, end);
 985 }
 986
 987 ti_iter_t ti_query(tabix_t *t, const char *name, int beg, int end)
 988 {
 989         int tid;
 990         if (name == 0) return ti_iter_first();
 991         // then need to load the index
 992         if (ti_lazy_index_load(t) != 0) return 0;
 993         if ((tid = ti_get_tid(t->idx, name)) < 0) return 0;
 994         return ti_iter_query(t->idx, tid, beg, end);
 995 }
 996
 997 const char *ti_read(tabix_t *t, ti_iter_t iter, int *len)
 998 {
 999         return ti_iter_read(t->fp, iter, len);
1000 }