c_cpp/lib/htslib/bgzip.c

   1 /* bgzip.c -- Block compression/decompression utility.
   2
   3    Copyright (C) 2008, 2009 Broad Institute / Massachusetts Institute of Technology
   4    Copyright (C) 2010, 2013-2017 Genome Research Ltd.
   5
   6    Permission is hereby granted, free of charge, to any person obtaining a copy
   7    of this software and associated documentation files (the "Software"), to deal
   8    in the Software without restriction, including without limitation the rights
   9    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10    copies of the Software, and to permit persons to whom the Software is
  11    furnished to do so, subject to the following conditions:
  12
  13    The above copyright notices and this permission notice shall be included in
  14    all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22    THE SOFTWARE.
  23 */
  24
  25 #include <config.h>
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <stdarg.h>
  34 #include <getopt.h>
  35 #include <sys/stat.h>
  36 #include "htslib/bgzf.h"
  37 #include "htslib/hts.h"
  38
  39 static const int WINDOW_SIZE = 64 * 1024;
  40
  41 static void error(const char *format, ...)
  42 {
  43     va_list ap;
  44     va_start(ap, format);
  45     vfprintf(stderr, format, ap);
  46     va_end(ap);
  47     exit(EXIT_FAILURE);
  48 }
  49
  50 static int confirm_overwrite(const char *fn)
  51 {
  52     int save_errno = errno;
  53     int ret = 0;
  54
  55     if (isatty(STDIN_FILENO)) {
  56         char c;
  57         fprintf(stderr, "[bgzip] %s already exists; do you wish to overwrite (y or n)? ", fn);
  58         if (scanf("%c", &c) == 1 && (c == 'Y' || c == 'y')) ret = 1;
  59     }
  60
  61     errno = save_errno;
  62     return ret;
  63 }
  64
  65 static int bgzip_main_usage(void)
  66 {
  67     fprintf(stderr, "\n");
  68     fprintf(stderr, "Version: %s\n", hts_version());
  69     fprintf(stderr, "Usage:   bgzip [OPTIONS] [FILE] ...\n");
  70     fprintf(stderr, "Options:\n");
  71     fprintf(stderr, "   -b, --offset INT        decompress at virtual file pointer (0-based uncompressed offset)\n");
  72     fprintf(stderr, "   -c, --stdout            write on standard output, keep original files unchanged\n");
  73     fprintf(stderr, "   -d, --decompress        decompress\n");
  74     fprintf(stderr, "   -f, --force             overwrite files without asking\n");
  75     fprintf(stderr, "   -h, --help              give this help\n");
  76     fprintf(stderr, "   -i, --index             compress and create BGZF index\n");
  77     fprintf(stderr, "   -I, --index-name FILE   name of BGZF index file [file.gz.gzi]\n");
  78     fprintf(stderr, "   -r, --reindex           (re)index compressed file\n");
  79     fprintf(stderr, "   -g, --rebgzip           use an index file to bgzip a file\n");
  80     fprintf(stderr, "   -s, --size INT          decompress INT bytes (uncompressed size)\n");
  81     fprintf(stderr, "   -@, --threads INT       number of compression threads to use [1]\n");
  82     fprintf(stderr, "\n");
  83     return 1;
  84 }
  85
  86 int main(int argc, char **argv)
  87 {
  88     int c, compress, pstdout, is_forced, index = 0, rebgzip = 0, reindex = 0;
  89     BGZF *fp;
  90     void *buffer;
  91     long start, end, size;
  92     char *index_fname = NULL;
  93     int threads = 1;
  94
  95     static const struct option loptions[] =
  96     {
  97         {"help", no_argument, NULL, 'h'},
  98         {"offset", required_argument, NULL, 'b'},
  99         {"stdout", no_argument, NULL, 'c'},
 100         {"decompress", no_argument, NULL, 'd'},
 101         {"force", no_argument, NULL, 'f'},
 102         {"index", no_argument, NULL, 'i'},
 103         {"index-name", required_argument, NULL, 'I'},
 104         {"reindex", no_argument, NULL, 'r'},
 105         {"rebgzip",no_argument,NULL,'g'},
 106         {"size", required_argument, NULL, 's'},
 107         {"threads", required_argument, NULL, '@'},
 108         {"version", no_argument, NULL, 1},
 109         {NULL, 0, NULL, 0}
 110     };
 111
 112     compress = 1; pstdout = 0; start = 0; size = -1; end = -1; is_forced = 0;
 113     while((c  = getopt_long(argc, argv, "cdh?fb:@:s:iI:gr",loptions,NULL)) >= 0){
 114         switch(c){
 115         case 'd': compress = 0; break;
 116         case 'c': pstdout = 1; break;
 117         case 'b': start = atol(optarg); compress = 0; pstdout = 1; break;
 118         case 's': size = atol(optarg); pstdout = 1; break;
 119         case 'f': is_forced = 1; break;
 120         case 'i': index = 1; break;
 121         case 'I': index_fname = optarg; break;
 122         case 'g': rebgzip = 1; break;
 123         case 'r': reindex = 1; compress = 0; break;
 124         case '@': threads = atoi(optarg); break;
 125         case 1:
 126             printf(
 127 "bgzip (htslib) %s\n"
 128 "Copyright (C) 2017 Genome Research Ltd.\n", hts_version());
 129             return EXIT_SUCCESS;
 130         case 'h':
 131         case '?': return bgzip_main_usage();
 132         }
 133     }
 134     if (size >= 0) end = start + size;
 135     if (end >= 0 && end < start) {
 136         fprintf(stderr, "[bgzip] Illegal region: [%ld, %ld]\n", start, end);
 137         return 1;
 138     }
 139     if (compress == 1) {
 140         struct stat sbuf;
 141         int f_src = fileno(stdin);
 142
 143         if ( argc>optind )
 144         {
 145             if ( stat(argv[optind],&sbuf)<0 )
 146             {
 147                 fprintf(stderr, "[bgzip] %s: %s\n", strerror(errno), argv[optind]);
 148                 return 1;
 149             }
 150
 151             if ((f_src = open(argv[optind], O_RDONLY)) < 0) {
 152                 fprintf(stderr, "[bgzip] %s: %s\n", strerror(errno), argv[optind]);
 153                 return 1;
 154             }
 155
 156             if (pstdout)
 157                 fp = bgzf_open("-", "w");
 158             else
 159             {
 160                 char *name = malloc(strlen(argv[optind]) + 5);
 161                 strcpy(name, argv[optind]);
 162                 strcat(name, ".gz");
 163                 fp = bgzf_open(name, is_forced? "w" : "wx");
 164                 if (fp == NULL && errno == EEXIST && confirm_overwrite(name))
 165                     fp = bgzf_open(name, "w");
 166                 if (fp == NULL) {
 167                     fprintf(stderr, "[bgzip] can't create %s: %s\n", name, strerror(errno));
 168                     free(name);
 169                     return 1;
 170                 }
 171                 free(name);
 172             }
 173         }
 174         else if (!pstdout && isatty(fileno((FILE *)stdout)) )
 175             return bgzip_main_usage();
 176         else if ( index && !index_fname )
 177         {
 178             fprintf(stderr, "[bgzip] Index file name expected when writing to stdout\n");
 179             return 1;
 180         }
 181         else
 182             fp = bgzf_open("-", "w");
 183
 184         if ( index && rebgzip )
 185         {
 186             fprintf(stderr, "[bgzip] Can't produce a index and rebgzip simultaneously\n");
 187             return 1;
 188         }
 189
 190         if ( rebgzip && !index_fname )
 191         {
 192             fprintf(stderr, "[bgzip] Index file name expected when writing to stdout\n");
 193             return 1;
 194         }
 195
 196         if (threads > 1)
 197             bgzf_mt(fp, threads, 256);
 198
 199         if ( index ) bgzf_index_build_init(fp);
 200         buffer = malloc(WINDOW_SIZE);
 201         if (rebgzip){
 202             if ( bgzf_index_load(fp, index_fname, NULL) < 0 ) error("Could not load index: %s.gzi\n", argv[optind]);
 203
 204             while ((c = read(f_src, buffer, WINDOW_SIZE)) > 0)
 205                 if (bgzf_block_write(fp, buffer, c) < 0) error("Could not write %d bytes: Error %d\n", c, fp->errcode);
 206         }
 207         else {
 208             while ((c = read(f_src, buffer, WINDOW_SIZE)) > 0)
 209                 if (bgzf_write(fp, buffer, c) < 0) error("Could not write %d bytes: Error %d\n", c, fp->errcode);
 210         }
 211         if ( index )
 212         {
 213             if (index_fname) {
 214                 if (bgzf_index_dump(fp, index_fname, NULL) < 0)
 215                     error("Could not write index to '%s'\n", index_fname);
 216             } else {
 217                 if (bgzf_index_dump(fp, argv[optind], ".gz.gzi") < 0)
 218                     error("Could not write index to '%s.gz.gzi'", argv[optind]);
 219             }
 220         }
 221         if (bgzf_close(fp) < 0) error("Close failed: Error %d", fp->errcode);
 222         if (argc > optind && !pstdout) unlink(argv[optind]);
 223         free(buffer);
 224         close(f_src);
 225         return 0;
 226     }
 227     else if ( reindex )
 228     {
 229         if ( argc>optind )
 230         {
 231             fp = bgzf_open(argv[optind], "r");
 232             if ( !fp ) error("[bgzip] Could not open file: %s\n", argv[optind]);
 233         }
 234         else
 235         {
 236             if ( !index_fname ) error("[bgzip] Index file name expected when reading from stdin\n");
 237             fp = bgzf_open("-", "r");
 238             if ( !fp ) error("[bgzip] Could not read from stdin: %s\n", strerror(errno));
 239         }
 240
 241         buffer = malloc(BGZF_BLOCK_SIZE);
 242         bgzf_index_build_init(fp);
 243         int ret;
 244         while ( (ret=bgzf_read(fp, buffer, BGZF_BLOCK_SIZE))>0 ) ;
 245         free(buffer);
 246         if ( ret<0 ) error("Is the file gzipped or bgzipped? The latter is required for indexing.\n");
 247
 248         if ( index_fname ) {
 249             if (bgzf_index_dump(fp, index_fname, NULL) < 0)
 250                 error("Could not write index to '%s'\n", index_fname);
 251         } else {
 252             if (bgzf_index_dump(fp, argv[optind], ".gzi") < 0)
 253                 error("Could not write index to '%s.gzi'\n", argv[optind]);
 254         }
 255
 256         if ( bgzf_close(fp)<0 ) error("Close failed: Error %d\n",fp->errcode);
 257         return 0;
 258     }
 259     else
 260     {
 261         struct stat sbuf;
 262         int f_dst;
 263
 264         if ( argc>optind )
 265         {
 266             if ( stat(argv[optind],&sbuf)<0 )
 267             {
 268                 fprintf(stderr, "[bgzip] %s: %s\n", strerror(errno), argv[optind]);
 269                 return 1;
 270             }
 271             char *name;
 272             int len = strlen(argv[optind]);
 273             if ( strcmp(argv[optind]+len-3,".gz") )
 274             {
 275                 fprintf(stderr, "[bgzip] %s: unknown suffix -- ignored\n", argv[optind]);
 276                 return 1;
 277             }
 278             fp = bgzf_open(argv[optind], "r");
 279             if (fp == NULL) {
 280                 fprintf(stderr, "[bgzip] Could not open file: %s\n", argv[optind]);
 281                 return 1;
 282             }
 283
 284             if (pstdout) {
 285                 f_dst = fileno(stdout);
 286             }
 287             else {
 288                 const int wrflags = O_WRONLY | O_CREAT | O_TRUNC;
 289                 name = strdup(argv[optind]);
 290                 name[strlen(name) - 3] = '\0';
 291                 f_dst = open(name, is_forced? wrflags : wrflags|O_EXCL, 0666);
 292                 if (f_dst < 0 && errno == EEXIST && confirm_overwrite(name))
 293                     f_dst = open(name, wrflags, 0666);
 294                 if (f_dst < 0) {
 295                     fprintf(stderr, "[bgzip] can't create %s: %s\n", name, strerror(errno));
 296                     free(name);
 297                     return 1;
 298                 }
 299                 free(name);
 300             }
 301         }
 302         else if (!pstdout && isatty(fileno((FILE *)stdin)) )
 303             return bgzip_main_usage();
 304         else
 305         {
 306             f_dst = fileno(stdout);
 307             fp = bgzf_open("-", "r");
 308             if (fp == NULL) {
 309                 fprintf(stderr, "[bgzip] Could not read from stdin: %s\n", strerror(errno));
 310                 return 1;
 311             }
 312         }
 313         if (threads > 1)
 314             bgzf_mt(fp, threads, 256);
 315
 316         buffer = malloc(WINDOW_SIZE);
 317         if ( start>0 )
 318         {
 319             if ( bgzf_index_load(fp, argv[optind], ".gzi") < 0 ) error("Could not load index: %s.gzi\n", argv[optind]);
 320             if ( bgzf_useek(fp, start, SEEK_SET) < 0 ) error("Could not seek to %d-th (uncompressd) byte\n", start);
 321         }
 322         while (1) {
 323             if (end < 0) c = bgzf_read(fp, buffer, WINDOW_SIZE);
 324             else c = bgzf_read(fp, buffer, (end - start > WINDOW_SIZE)? WINDOW_SIZE:(end - start));
 325             if (c == 0) break;
 326             if (c < 0) error("Could not read %d bytes: Error %d\n", (end - start > WINDOW_SIZE)? WINDOW_SIZE:(end - start), fp->errcode);
 327             start += c;
 328             if ( write(f_dst, buffer, c) != c ) error("Could not write %d bytes\n", c);
 329             if (end >= 0 && start >= end) break;
 330         }
 331         free(buffer);
 332         if (bgzf_close(fp) < 0) error("Close failed: Error %d\n",fp->errcode);
 333         if (!pstdout) unlink(argv[optind]);
 334         return 0;
 335     }
 336 }