| 1 |
// Copyright ©2012 The bíogo Authors. All rights reserved. |
| 2 |
// Use of this source code is governed by a BSD-style |
| 3 |
// license that can be found in the LICENSE file. |
| 4 |
|
| 5 |
package bgzf |
| 6 |
|
| 7 |
import ( |
| 8 |
"bytes" |
| 9 |
"compress/gzip" |
| 10 |
"fmt" |
| 11 |
"io" |
| 12 |
"sync" |
| 13 |
) |
| 14 |
|
| 15 |
// Writer implements BGZF blocked gzip compression. |
| 16 |
// |
| 17 |
// Because the SAM specification requires that the RFC1952 FLG header field |
| 18 |
// be set to 0x04, a Writer's Name and Comment fields should not be set if |
| 19 |
// its output is to be read by another BGZF decompressor implementation. |
| 20 |
type Writer struct { |
| 21 |
gzip.Header |
| 22 |
w io.Writer |
| 23 |
|
| 24 |
active *compressor |
| 25 |
|
| 26 |
queue chan *compressor |
| 27 |
qwg sync.WaitGroup |
| 28 |
|
| 29 |
waiting chan *compressor |
| 30 |
|
| 31 |
wg sync.WaitGroup |
| 32 |
|
| 33 |
closed bool |
| 34 |
|
| 35 |
m sync.Mutex |
| 36 |
err error |
| 37 |
} |
| 38 |
|
| 39 |
// NewWriter returns a new Writer. Writes to the returned writer are |
| 40 |
// compressed and written to w. |
| 41 |
// |
| 42 |
// The number of concurrent write compressors is specified by wc. |
| 43 |
func NewWriter(w io.Writer, wc int) *Writer { |
| 44 |
bg, _ := NewWriterLevel(w, gzip.DefaultCompression, wc) |
| 45 |
return bg |
| 46 |
} |
| 47 |
|
| 48 |
// NewWriterLevel returns a new Writer using the specified compression level |
| 49 |
// instead of gzip.DefaultCompression. Allowable level options are integer |
| 50 |
// values between between gzip.BestSpeed and gzip.BestCompression inclusive. |
| 51 |
// |
| 52 |
// The number of concurrent write compressors is specified by wc. |
| 53 |
func NewWriterLevel(w io.Writer, level, wc int) (*Writer, error) { |
| 54 |
if level < gzip.DefaultCompression || level > gzip.BestCompression { |
| 55 |
return nil, fmt.Errorf("bgzf: invalid compression level: %d", level) |
| 56 |
} |
| 57 |
wc++ // We count one for the active compressor. |
| 58 |
if wc < 2 { |
| 59 |
wc = 2 |
| 60 |
} |
| 61 |
bg := &Writer{ |
| 62 |
w: w, |
| 63 |
waiting: make(chan *compressor, wc), |
| 64 |
queue: make(chan *compressor, wc), |
| 65 |
} |
| 66 |
bg.Header.OS = 0xff // Set default OS to unknown. |
| 67 |
|
| 68 |
c := make([]compressor, wc) |
| 69 |
for i := range c { |
| 70 |
c[i].Header = &bg.Header |
| 71 |
c[i].level = level |
| 72 |
c[i].waiting = bg.waiting |
| 73 |
c[i].flush = make(chan *compressor, 1) |
| 74 |
c[i].qwg = &bg.qwg |
| 75 |
bg.waiting <- &c[i] |
| 76 |
} |
| 77 |
bg.active = <-bg.waiting |
| 78 |
|
| 79 |
bg.wg.Add(1) |
| 80 |
go func() { |
| 81 |
defer bg.wg.Done() |
| 82 |
for qw := range bg.queue { |
| 83 |
if !writeOK(bg, <-qw.flush) { |
| 84 |
break |
| 85 |
} |
| 86 |
} |
| 87 |
}() |
| 88 |
|
| 89 |
return bg, nil |
| 90 |
} |
| 91 |
|
| 92 |
func writeOK(bg *Writer, c *compressor) bool { |
| 93 |
defer func() { bg.waiting <- c }() |
| 94 |
|
| 95 |
if c.err != nil { |
| 96 |
bg.setErr(c.err) |
| 97 |
return false |
| 98 |
} |
| 99 |
if c.buf.Len() == 0 { |
| 100 |
return true |
| 101 |
} |
| 102 |
|
| 103 |
_, err := io.Copy(bg.w, &c.buf) |
| 104 |
bg.qwg.Done() |
| 105 |
if err != nil { |
| 106 |
bg.setErr(err) |
| 107 |
return false |
| 108 |
} |
| 109 |
c.next = 0 |
| 110 |
|
| 111 |
return true |
| 112 |
} |
| 113 |
|
| 114 |
type compressor struct { |
| 115 |
*gzip.Header |
| 116 |
gz *gzip.Writer |
| 117 |
level int |
| 118 |
|
| 119 |
next int |
| 120 |
block [BlockSize]byte |
| 121 |
buf bytes.Buffer |
| 122 |
|
| 123 |
flush chan *compressor |
| 124 |
qwg *sync.WaitGroup |
| 125 |
|
| 126 |
waiting chan *compressor |
| 127 |
|
| 128 |
err error |
| 129 |
} |
| 130 |
|
| 131 |
func (c *compressor) writeBlock() { |
| 132 |
defer func() { c.flush <- c }() |
| 133 |
|
| 134 |
if c.gz == nil { |
| 135 |
c.gz, c.err = gzip.NewWriterLevel(&c.buf, c.level) |
| 136 |
if c.err != nil { |
| 137 |
return |
| 138 |
} |
| 139 |
} else { |
| 140 |
c.gz.Reset(&c.buf) |
| 141 |
} |
| 142 |
c.gz.Header = gzip.Header{ |
| 143 |
Comment: c.Comment, |
| 144 |
Extra: append([]byte(bgzfExtra), c.Extra...), |
| 145 |
ModTime: c.ModTime, |
| 146 |
Name: c.Name, |
| 147 |
OS: c.OS, |
| 148 |
} |
| 149 |
|
| 150 |
_, c.err = c.gz.Write(c.block[:c.next]) |
| 151 |
if c.err != nil { |
| 152 |
return |
| 153 |
} |
| 154 |
c.err = c.gz.Close() |
| 155 |
if c.err != nil { |
| 156 |
return |
| 157 |
} |
| 158 |
c.next = 0 |
| 159 |
|
| 160 |
b := c.buf.Bytes() |
| 161 |
i := bytes.Index(b, bgzfExtraPrefix) |
| 162 |
if i < 0 { |
| 163 |
c.err = gzip.ErrHeader |
| 164 |
return |
| 165 |
} |
| 166 |
size := len(b) - 1 |
| 167 |
if size >= MaxBlockSize { |
| 168 |
c.err = ErrBlockOverflow |
| 169 |
return |
| 170 |
} |
| 171 |
b[i+4], b[i+5] = byte(size), byte(size>>8) |
| 172 |
} |
| 173 |
|
| 174 |
// Next returns the index of the start of the next write within the |
| 175 |
// decompressed data block. |
| 176 |
func (bg *Writer) Next() (int, error) { |
| 177 |
if bg.closed { |
| 178 |
return 0, ErrClosed |
| 179 |
} |
| 180 |
if err := bg.Error(); err != nil { |
| 181 |
return 0, err |
| 182 |
} |
| 183 |
|
| 184 |
return bg.active.next, nil |
| 185 |
} |
| 186 |
|
| 187 |
// Write writes the compressed form of b to the underlying io.Writer. |
| 188 |
// Decompressed data blocks are limited to BlockSize, so individual |
| 189 |
// byte slices may span block boundaries, however the Writer attempts |
| 190 |
// to keep each write within a single data block. |
| 191 |
func (bg *Writer) Write(b []byte) (int, error) { |
| 192 |
if bg.closed { |
| 193 |
return 0, ErrClosed |
| 194 |
} |
| 195 |
err := bg.Error() |
| 196 |
if err != nil { |
| 197 |
return 0, err |
| 198 |
} |
| 199 |
|
| 200 |
c := bg.active |
| 201 |
var n int |
| 202 |
for ; len(b) > 0 && err == nil; err = bg.Error() { |
| 203 |
var _n int |
| 204 |
if c.next == 0 || c.next+len(b) <= len(c.block) { |
| 205 |
_n = copy(c.block[c.next:], b) |
| 206 |
b = b[_n:] |
| 207 |
c.next += _n |
| 208 |
n += _n |
| 209 |
} |
| 210 |
|
| 211 |
if c.next == len(c.block) || _n == 0 { |
| 212 |
bg.queue <- c |
| 213 |
bg.qwg.Add(1) |
| 214 |
go c.writeBlock() |
| 215 |
c = <-bg.waiting |
| 216 |
} |
| 217 |
} |
| 218 |
bg.active = c |
| 219 |
|
| 220 |
return n, bg.Error() |
| 221 |
} |
| 222 |
|
| 223 |
// Flush writes unwritten data to the underlying io.Writer. Flush does not block. |
| 224 |
func (bg *Writer) Flush() error { |
| 225 |
if bg.closed { |
| 226 |
return ErrClosed |
| 227 |
} |
| 228 |
if err := bg.Error(); err != nil { |
| 229 |
return err |
| 230 |
} |
| 231 |
|
| 232 |
if bg.active.next == 0 { |
| 233 |
return nil |
| 234 |
} |
| 235 |
|
| 236 |
var c *compressor |
| 237 |
c, bg.active = bg.active, <-bg.waiting |
| 238 |
bg.queue <- c |
| 239 |
bg.qwg.Add(1) |
| 240 |
go c.writeBlock() |
| 241 |
|
| 242 |
return bg.Error() |
| 243 |
} |
| 244 |
|
| 245 |
// Wait waits for all pending writes to complete and returns the subsequent |
| 246 |
// error state of the Writer. |
| 247 |
func (bg *Writer) Wait() error { |
| 248 |
if err := bg.Error(); err != nil { |
| 249 |
return err |
| 250 |
} |
| 251 |
bg.qwg.Wait() |
| 252 |
return bg.Error() |
| 253 |
} |
| 254 |
|
| 255 |
// Error returns the error state of the Writer. |
| 256 |
func (bg *Writer) Error() error { |
| 257 |
bg.m.Lock() |
| 258 |
defer bg.m.Unlock() |
| 259 |
return bg.err |
| 260 |
} |
| 261 |
|
| 262 |
func (bg *Writer) setErr(err error) { |
| 263 |
bg.m.Lock() |
| 264 |
defer bg.m.Unlock() |
| 265 |
if bg.err == nil { |
| 266 |
bg.err = err |
| 267 |
} |
| 268 |
} |
| 269 |
|
| 270 |
// Close closes the Writer, waiting for any pending writes before returning |
| 271 |
// the final error of the Writer. |
| 272 |
func (bg *Writer) Close() error { |
| 273 |
if !bg.closed { |
| 274 |
c := bg.active |
| 275 |
bg.queue <- c |
| 276 |
bg.qwg.Add(1) |
| 277 |
<-bg.waiting |
| 278 |
c.writeBlock() |
| 279 |
bg.closed = true |
| 280 |
close(bg.queue) |
| 281 |
bg.wg.Wait() |
| 282 |
if bg.err == nil { |
| 283 |
_, bg.err = bg.w.Write([]byte(magicBlock)) |
| 284 |
} |
| 285 |
} |
| 286 |
return bg.err |
| 287 |
} |