index.c

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