989489096e
This commit implements a massive refactor of the repository, and moves the build system over to use Mage (magefile.org) which should allow seamless building across multiple platforms.
306 lines
7.1 KiB
Go
306 lines
7.1 KiB
Go
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package lzma
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"io"
|
|
)
|
|
|
|
// Writer2Config is used to create a Writer2 using parameters.
|
|
type Writer2Config struct {
|
|
// The properties for the encoding. If the it is nil the value
|
|
// {LC: 3, LP: 0, PB: 2} will be chosen.
|
|
Properties *Properties
|
|
// The capacity of the dictionary. If DictCap is zero, the value
|
|
// 8 MiB will be chosen.
|
|
DictCap int
|
|
// Size of the lookahead buffer; value 0 indicates default size
|
|
// 4096
|
|
BufSize int
|
|
// Match algorithm
|
|
Matcher MatchAlgorithm
|
|
}
|
|
|
|
// fill replaces zero values with default values.
|
|
func (c *Writer2Config) fill() {
|
|
if c.Properties == nil {
|
|
c.Properties = &Properties{LC: 3, LP: 0, PB: 2}
|
|
}
|
|
if c.DictCap == 0 {
|
|
c.DictCap = 8 * 1024 * 1024
|
|
}
|
|
if c.BufSize == 0 {
|
|
c.BufSize = 4096
|
|
}
|
|
}
|
|
|
|
// Verify checks the Writer2Config for correctness. Zero values will be
|
|
// replaced by default values.
|
|
func (c *Writer2Config) Verify() error {
|
|
c.fill()
|
|
var err error
|
|
if c == nil {
|
|
return errors.New("lzma: WriterConfig is nil")
|
|
}
|
|
if c.Properties == nil {
|
|
return errors.New("lzma: WriterConfig has no Properties set")
|
|
}
|
|
if err = c.Properties.verify(); err != nil {
|
|
return err
|
|
}
|
|
if !(MinDictCap <= c.DictCap && int64(c.DictCap) <= MaxDictCap) {
|
|
return errors.New("lzma: dictionary capacity is out of range")
|
|
}
|
|
if !(maxMatchLen <= c.BufSize) {
|
|
return errors.New("lzma: lookahead buffer size too small")
|
|
}
|
|
if c.Properties.LC+c.Properties.LP > 4 {
|
|
return errors.New("lzma: sum of lc and lp exceeds 4")
|
|
}
|
|
if err = c.Matcher.verify(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Writer2 supports the creation of an LZMA2 stream. But note that
|
|
// written data is buffered, so call Flush or Close to write data to the
|
|
// underlying writer. The Close method writes the end-of-stream marker
|
|
// to the stream. So you may be able to concatenate the output of two
|
|
// writers as long the output of the first writer has only been flushed
|
|
// but not closed.
|
|
//
|
|
// Any change to the fields Properties, DictCap must be done before the
|
|
// first call to Write, Flush or Close.
|
|
type Writer2 struct {
|
|
w io.Writer
|
|
|
|
start *state
|
|
encoder *encoder
|
|
|
|
cstate chunkState
|
|
ctype chunkType
|
|
|
|
buf bytes.Buffer
|
|
lbw LimitedByteWriter
|
|
}
|
|
|
|
// NewWriter2 creates an LZMA2 chunk sequence writer with the default
|
|
// parameters and options.
|
|
func NewWriter2(lzma2 io.Writer) (w *Writer2, err error) {
|
|
return Writer2Config{}.NewWriter2(lzma2)
|
|
}
|
|
|
|
// NewWriter2 creates a new LZMA2 writer using the given configuration.
|
|
func (c Writer2Config) NewWriter2(lzma2 io.Writer) (w *Writer2, err error) {
|
|
if err = c.Verify(); err != nil {
|
|
return nil, err
|
|
}
|
|
w = &Writer2{
|
|
w: lzma2,
|
|
start: newState(*c.Properties),
|
|
cstate: start,
|
|
ctype: start.defaultChunkType(),
|
|
}
|
|
w.buf.Grow(maxCompressed)
|
|
w.lbw = LimitedByteWriter{BW: &w.buf, N: maxCompressed}
|
|
m, err := c.Matcher.new(c.DictCap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
d, err := newEncoderDict(c.DictCap, c.BufSize, m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
w.encoder, err = newEncoder(&w.lbw, cloneState(w.start), d, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return w, nil
|
|
}
|
|
|
|
// written returns the number of bytes written to the current chunk
|
|
func (w *Writer2) written() int {
|
|
if w.encoder == nil {
|
|
return 0
|
|
}
|
|
return int(w.encoder.Compressed()) + w.encoder.dict.Buffered()
|
|
}
|
|
|
|
// errClosed indicates that the writer is closed.
|
|
var errClosed = errors.New("lzma: writer closed")
|
|
|
|
// Writes data to LZMA2 stream. Note that written data will be buffered.
|
|
// Use Flush or Close to ensure that data is written to the underlying
|
|
// writer.
|
|
func (w *Writer2) Write(p []byte) (n int, err error) {
|
|
if w.cstate == stop {
|
|
return 0, errClosed
|
|
}
|
|
for n < len(p) {
|
|
m := maxUncompressed - w.written()
|
|
if m <= 0 {
|
|
panic("lzma: maxUncompressed reached")
|
|
}
|
|
var q []byte
|
|
if n+m < len(p) {
|
|
q = p[n : n+m]
|
|
} else {
|
|
q = p[n:]
|
|
}
|
|
k, err := w.encoder.Write(q)
|
|
n += k
|
|
if err != nil && err != ErrLimit {
|
|
return n, err
|
|
}
|
|
if err == ErrLimit || k == m {
|
|
if err = w.flushChunk(); err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// writeUncompressedChunk writes an uncompressed chunk to the LZMA2
|
|
// stream.
|
|
func (w *Writer2) writeUncompressedChunk() error {
|
|
u := w.encoder.Compressed()
|
|
if u <= 0 {
|
|
return errors.New("lzma: can't write empty uncompressed chunk")
|
|
}
|
|
if u > maxUncompressed {
|
|
panic("overrun of uncompressed data limit")
|
|
}
|
|
switch w.ctype {
|
|
case cLRND:
|
|
w.ctype = cUD
|
|
default:
|
|
w.ctype = cU
|
|
}
|
|
w.encoder.state = w.start
|
|
|
|
header := chunkHeader{
|
|
ctype: w.ctype,
|
|
uncompressed: uint32(u - 1),
|
|
}
|
|
hdata, err := header.MarshalBinary()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err = w.w.Write(hdata); err != nil {
|
|
return err
|
|
}
|
|
_, err = w.encoder.dict.CopyN(w.w, int(u))
|
|
return err
|
|
}
|
|
|
|
// writeCompressedChunk writes a compressed chunk to the underlying
|
|
// writer.
|
|
func (w *Writer2) writeCompressedChunk() error {
|
|
if w.ctype == cU || w.ctype == cUD {
|
|
panic("chunk type uncompressed")
|
|
}
|
|
|
|
u := w.encoder.Compressed()
|
|
if u <= 0 {
|
|
return errors.New("writeCompressedChunk: empty chunk")
|
|
}
|
|
if u > maxUncompressed {
|
|
panic("overrun of uncompressed data limit")
|
|
}
|
|
c := w.buf.Len()
|
|
if c <= 0 {
|
|
panic("no compressed data")
|
|
}
|
|
if c > maxCompressed {
|
|
panic("overrun of compressed data limit")
|
|
}
|
|
header := chunkHeader{
|
|
ctype: w.ctype,
|
|
uncompressed: uint32(u - 1),
|
|
compressed: uint16(c - 1),
|
|
props: w.encoder.state.Properties,
|
|
}
|
|
hdata, err := header.MarshalBinary()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err = w.w.Write(hdata); err != nil {
|
|
return err
|
|
}
|
|
_, err = io.Copy(w.w, &w.buf)
|
|
return err
|
|
}
|
|
|
|
// writes a single chunk to the underlying writer.
|
|
func (w *Writer2) writeChunk() error {
|
|
u := int(uncompressedHeaderLen + w.encoder.Compressed())
|
|
c := headerLen(w.ctype) + w.buf.Len()
|
|
if u < c {
|
|
return w.writeUncompressedChunk()
|
|
}
|
|
return w.writeCompressedChunk()
|
|
}
|
|
|
|
// flushChunk terminates the current chunk. The encoder will be reset
|
|
// to support the next chunk.
|
|
func (w *Writer2) flushChunk() error {
|
|
if w.written() == 0 {
|
|
return nil
|
|
}
|
|
var err error
|
|
if err = w.encoder.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err = w.writeChunk(); err != nil {
|
|
return err
|
|
}
|
|
w.buf.Reset()
|
|
w.lbw.N = maxCompressed
|
|
if err = w.encoder.Reopen(&w.lbw); err != nil {
|
|
return err
|
|
}
|
|
if err = w.cstate.next(w.ctype); err != nil {
|
|
return err
|
|
}
|
|
w.ctype = w.cstate.defaultChunkType()
|
|
w.start = cloneState(w.encoder.state)
|
|
return nil
|
|
}
|
|
|
|
// Flush writes all buffered data out to the underlying stream. This
|
|
// could result in multiple chunks to be created.
|
|
func (w *Writer2) Flush() error {
|
|
if w.cstate == stop {
|
|
return errClosed
|
|
}
|
|
for w.written() > 0 {
|
|
if err := w.flushChunk(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Close terminates the LZMA2 stream with an EOS chunk.
|
|
func (w *Writer2) Close() error {
|
|
if w.cstate == stop {
|
|
return errClosed
|
|
}
|
|
if err := w.Flush(); err != nil {
|
|
return nil
|
|
}
|
|
// write zero byte EOS chunk
|
|
_, err := w.w.Write([]byte{0})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w.cstate = stop
|
|
return nil
|
|
}
|