Debian Codegraph @

bgzf/writer.go

raw
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 }