bcftools/bcf.h

   1 /* The MIT License
   2
   3    Copyright (c) 2010 Broad Institute
   4
   5    Permission is hereby granted, free of charge, to any person obtaining
   6    a copy of this software and associated documentation files (the
   7    "Software"), to deal in the Software without restriction, including
   8    without limitation the rights to use, copy, modify, merge, publish,
   9    distribute, sublicense, and/or sell copies of the Software, and to
  10    permit persons to whom the Software is furnished to do so, subject to
  11    the following conditions:
  12
  13    The above copyright notice and this permission notice shall be
  14    included in all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  20    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  21    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23    SOFTWARE.
  24 */
  25
  26 /* Contact: Heng Li <lh3@live.co.uk> */
  27
  28 #ifndef BCF_H
  29 #define BCF_H
  30
  31 #ifndef VERSION
  32 #define BCF_VERSION "0.1.19+"
  33 #else
  34 #define BCF_VERSION VERSION
  35 #endif
  36
  37 #include <stdint.h>
  38 #include <zlib.h>
  39
  40 #ifndef BCF_LITE
  41 #include "bgzf.h"
  42 typedef BGZF *bcfFile;
  43 #else
  44 typedef gzFile bcfFile;
  45 #define bgzf_open(fn, mode) gzopen(fn, mode)
  46 #define bgzf_fdopen(fd, mode) gzdopen(fd, mode)
  47 #define bgzf_close(fp) gzclose(fp)
  48 #define bgzf_read(fp, buf, len) gzread(fp, buf, len)
  49 #define bgzf_write(fp, buf, len)
  50 #define bgzf_flush(fp)
  51 #endif
  52
  53 /*
  54   A member in the structs below is said to "primary" if its content
  55   cannot be inferred from other members in any of structs below; a
  56   member is said to be "derived" if its content can be derived from
  57   other members. For example, bcf1_t::str is primary as this comes from
  58   the input data, while bcf1_t::info is derived as it can always be
  59   correctly set if we know bcf1_t::str. Derived members are for quick
  60   access to the content and must be synchronized with the primary data.
  61  */
  62
  63 typedef struct {
  64         uint32_t fmt; // format of the block, set by bcf_str2int().
  65         int len; // length of data for each individual
  66         void *data; // concatenated data
  67         // derived info: fmt, len (<-bcf1_t::fmt)
  68 } bcf_ginfo_t;
  69
  70 typedef struct {
  71         int32_t tid, pos; // refID and 0-based position
  72         int32_t l_str, m_str; // length and the allocated size of ->str
  73         float qual; // SNP quality
  74         char *str; // concatenated string of variable length strings in VCF (from col.2 to col.7)
  75         char *ref, *alt, *flt, *info, *fmt; // they all point to ->str; no memory allocation
  76         int n_gi, m_gi; // number and the allocated size of geno fields
  77         bcf_ginfo_t *gi; // array of geno fields
  78         int n_alleles, n_smpl; // number of alleles and samples
  79         // derived info: ref, alt, flt, info, fmt (<-str), n_gi (<-fmt), n_alleles (<-alt), n_smpl (<-bcf_hdr_t::n_smpl)
  80     uint8_t *ploidy;    // ploidy of all samples; if NULL, ploidy of 2 is assumed.
  81 } bcf1_t;
  82
  83 typedef struct {
  84         int32_t n_ref, n_smpl; // number of reference sequences and samples
  85         int32_t l_nm; // length of concatenated sequence names; 0 padded
  86         int32_t l_smpl; // length of concatenated sample names; 0 padded
  87         int32_t l_txt; // length of header text (lines started with ##)
  88         char *name, *sname, *txt; // concatenated sequence names, sample names and header text
  89         char **ns, **sns; // array of sequence and sample names; point to name and sname, respectively
  90         // derived info: n_ref (<-name), n_smpl (<-sname), ns (<-name), sns (<-sname)
  91 } bcf_hdr_t;
  92
  93 typedef struct {
  94         int is_vcf; // if the file in operation is a VCF
  95         void *v; // auxillary data structure for VCF
  96         bcfFile fp; // file handler for BCF
  97 } bcf_t;
  98
  99 struct __bcf_idx_t;
 100 typedef struct __bcf_idx_t bcf_idx_t;
 101
 102 #ifdef __cplusplus
 103 extern "C" {
 104 #endif
 105
 106         // open a BCF file; for BCF file only
 107         bcf_t *bcf_open(const char *fn, const char *mode);
 108         // close file
 109         int bcf_close(bcf_t *b);
 110         // read one record from BCF; return -1 on end-of-file, and <-1 for errors
 111         int bcf_read(bcf_t *bp, const bcf_hdr_t *h, bcf1_t *b);
 112         // call this function if b->str is changed
 113         int bcf_sync(bcf1_t *b);
 114         // write a BCF record
 115         int bcf_write(bcf_t *bp, const bcf_hdr_t *h, const bcf1_t *b);
 116         // read the BCF header; BCF only
 117         bcf_hdr_t *bcf_hdr_read(bcf_t *b);
 118         // write the BCF header
 119         int bcf_hdr_write(bcf_t *b, const bcf_hdr_t *h);
 120         // set bcf_hdr_t::ns and bcf_hdr_t::sns
 121         int bcf_hdr_sync(bcf_hdr_t *b);
 122         // destroy the header
 123         void bcf_hdr_destroy(bcf_hdr_t *h);
 124         // destroy a record
 125         int bcf_destroy(bcf1_t *b);
 126         // BCF->VCF conversion
 127         char *bcf_fmt(const bcf_hdr_t *h, bcf1_t *b);
 128         // append more info
 129         int bcf_append_info(bcf1_t *b, const char *info, int l);
 130     // remove tag
 131     int remove_tag(char *string, const char *tag, char delim);
 132     // remove info tag, string is the kstring holder of bcf1_t.str
 133     void rm_info(kstring_t *string, const char *key);
 134         // copy
 135         int bcf_cpy(bcf1_t *r, const bcf1_t *b);
 136
 137         // open a VCF or BCF file if "b" is set in "mode"
 138         bcf_t *vcf_open(const char *fn, const char *mode);
 139         // close a VCF/BCF file
 140         int vcf_close(bcf_t *bp);
 141         // read the VCF/BCF header
 142         bcf_hdr_t *vcf_hdr_read(bcf_t *bp);
 143         // read the sequence dictionary from a separate file; required for VCF->BCF conversion
 144         int vcf_dictread(bcf_t *bp, bcf_hdr_t *h, const char *fn);
 145         // read a VCF/BCF record; return -1 on end-of-file and <-1 for errors
 146         int vcf_read(bcf_t *bp, bcf_hdr_t *h, bcf1_t *b);
 147         // write the VCF header
 148         int vcf_hdr_write(bcf_t *bp, const bcf_hdr_t *h);
 149         // write a VCF record
 150         int vcf_write(bcf_t *bp, bcf_hdr_t *h, bcf1_t *b);
 151
 152         // keep the first n alleles and discard the rest
 153         int bcf_shrink_alt(bcf1_t *b, int n);
 154     // keep the masked alleles and discard the rest
 155         void bcf_fit_alt(bcf1_t *b, int mask);
 156         // convert GL to PL
 157         int bcf_gl2pl(bcf1_t *b);
 158         // if the site is an indel
 159         int bcf_is_indel(const bcf1_t *b);
 160         bcf_hdr_t *bcf_hdr_subsam(const bcf_hdr_t *h0, int n, char *const* samples, int *list);
 161         int bcf_subsam(int n_smpl, int *list, bcf1_t *b);
 162         // move GT to the first FORMAT field
 163         int bcf_fix_gt(bcf1_t *b);
 164         // update PL generated by old samtools
 165         int bcf_fix_pl(bcf1_t *b);
 166         // convert PL to GLF-like 10-likelihood GL
 167         int bcf_gl10(const bcf1_t *b, uint8_t *gl);
 168         // convert up to 4 INDEL alleles to GLF-like 10-likelihood GL
 169         int bcf_gl10_indel(const bcf1_t *b, uint8_t *gl);
 170
 171         // string hash table
 172         void *bcf_build_refhash(bcf_hdr_t *h);
 173         void bcf_str2id_destroy(void *_hash);
 174         void bcf_str2id_thorough_destroy(void *_hash);
 175         int bcf_str2id_add(void *_hash, const char *str);
 176         int bcf_str2id(void *_hash, const char *str);
 177         void *bcf_str2id_init();
 178
 179         // indexing related functions
 180         int bcf_idx_build(const char *fn);
 181         uint64_t bcf_idx_query(const bcf_idx_t *idx, int tid, int beg);
 182         int bcf_parse_region(void *str2id, const char *str, int *tid, int *begin, int *end);
 183         bcf_idx_t *bcf_idx_load(const char *fn);
 184         void bcf_idx_destroy(bcf_idx_t *idx);
 185
 186 #ifdef __cplusplus
 187 }
 188 #endif
 189
 190 static inline uint32_t bcf_str2int(const char *str, int l)
 191 {
 192         int i;
 193         uint32_t x = 0;
 194         for (i = 0; i < l && i < 4; ++i) {
 195                 if (str[i] == 0) return x;
 196                 x = x<<8 | str[i];
 197         }
 198         return x;
 199 }
 200
 201 #endif