mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Add a lib/cgozlib package
This commit is contained in:
1 parent
1fa39758cf
commit
a93d5a8ea7
2 files changed
+348
No files matched your search
@@ -0,0 +1,239 @@
|
||||
// Copyright 2019 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// ----------------
|
||||
|
||||
// Package cgozlib wraps the C "zlib" library.
|
||||
//
|
||||
// Unlike some other wrappers, this one supports dictionaries.
|
||||
package cgozlib
|
||||
|
||||
/*
|
||||
#cgo pkg-config: zlib
|
||||
#include "zlib.h"
|
||||
|
||||
typedef struct {
|
||||
uInt ndst;
|
||||
uInt nsrc;
|
||||
} advances;
|
||||
|
||||
int cgozlib_inflateInit(z_stream* z) {
|
||||
return inflateInit(z);
|
||||
}
|
||||
|
||||
int cgozlib_inflateSetDictionary(z_stream* z,
|
||||
Bytef* dict_ptr,
|
||||
uInt dict_len) {
|
||||
return inflateSetDictionary(z, dict_ptr, dict_len);
|
||||
}
|
||||
|
||||
int cgozlib_inflate(z_stream* z,
|
||||
advances *a,
|
||||
Bytef* next_out,
|
||||
uInt avail_out,
|
||||
Bytef* next_in,
|
||||
uInt avail_in) {
|
||||
z->next_out = next_out;
|
||||
z->avail_out = avail_out;
|
||||
z->next_in = next_in;
|
||||
z->avail_in = avail_in;
|
||||
|
||||
int ret = inflate(z, Z_NO_FLUSH);
|
||||
|
||||
a->ndst = avail_out - z->avail_out;
|
||||
a->nsrc = avail_in - z->avail_in;
|
||||
|
||||
z->next_out = NULL;
|
||||
z->avail_out = 0;
|
||||
z->next_in = NULL;
|
||||
z->avail_in = 0;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int cgozlib_inflateEnd(z_stream* z) {
|
||||
return inflateEnd(z);
|
||||
}
|
||||
*/
|
||||
import "C"
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
var (
|
||||
errMissingResetCall = errors.New("cgozlib: missing Reset call")
|
||||
errNilIOReader = errors.New("cgozlib: nil io.Reader")
|
||||
errNilReceiver = errors.New("cgozlib: nil receiver")
|
||||
)
|
||||
|
||||
const (
|
||||
errCodeStreamEnd = 1
|
||||
errCodeNeedDict = 2
|
||||
)
|
||||
|
||||
type errCode int32
|
||||
|
||||
func (e errCode) Error() string {
|
||||
switch e {
|
||||
case +1:
|
||||
return "cgozlib: Z_STREAM_END"
|
||||
case +2:
|
||||
return "cgozlib: Z_NEED_DICT"
|
||||
case -1:
|
||||
return "cgozlib: Z_ERRNO"
|
||||
case -2:
|
||||
return "cgozlib: Z_STREAM_ERROR"
|
||||
case -3:
|
||||
return "cgozlib: Z_DATA_ERROR"
|
||||
case -4:
|
||||
return "cgozlib: Z_MEM_ERROR"
|
||||
case -5:
|
||||
return "cgozlib: Z_BUF_ERROR"
|
||||
case -6:
|
||||
return "cgozlib: Z_VERSION_ERROR"
|
||||
}
|
||||
return "cgozlib: unknown zlib error"
|
||||
}
|
||||
|
||||
// Reader is both a zlib.Resetter and an io.ReadCloser. Call Reset before
|
||||
// calling Read.
|
||||
//
|
||||
// It is analogous to the value returned by zlib.NewReader in the Go standard
|
||||
// library.
|
||||
type Reader struct {
|
||||
buf [4096]byte
|
||||
i, j uint32
|
||||
r io.Reader
|
||||
dict []byte
|
||||
|
||||
readErr error
|
||||
zlibErr error
|
||||
|
||||
z C.z_stream
|
||||
a C.advances
|
||||
}
|
||||
|
||||
// Reset implements zlib.Resetter.
|
||||
func (r *Reader) Reset(reader io.Reader, dictionary []byte) error {
|
||||
if r == nil {
|
||||
return errNilReceiver
|
||||
}
|
||||
if reader == nil {
|
||||
return errNilIOReader
|
||||
}
|
||||
if err := r.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if e := C.cgozlib_inflateInit(&r.z); e != 0 {
|
||||
return errCode(e)
|
||||
}
|
||||
|
||||
r.r = reader
|
||||
r.dict = dictionary
|
||||
if n := len(r.dict); n > 32768 {
|
||||
r.dict = r.dict[n-32768:]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close implements io.Closer.
|
||||
func (r *Reader) Close() error {
|
||||
if r == nil {
|
||||
return errNilReceiver
|
||||
}
|
||||
if r.r == nil {
|
||||
return nil
|
||||
}
|
||||
r.i = 0
|
||||
r.j = 0
|
||||
r.r = nil
|
||||
r.dict = nil
|
||||
r.readErr = nil
|
||||
r.zlibErr = nil
|
||||
if e := C.cgozlib_inflateEnd(&r.z); e != 0 {
|
||||
return errCode(e)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Read implements io.Reader.
|
||||
func (r *Reader) Read(p []byte) (int, error) {
|
||||
if r == nil {
|
||||
return 0, errNilReceiver
|
||||
}
|
||||
if r.r == nil {
|
||||
return 0, errMissingResetCall
|
||||
}
|
||||
|
||||
const maxLen = 1 << 30
|
||||
if len(p) > maxLen {
|
||||
p = p[:maxLen]
|
||||
}
|
||||
|
||||
for numRead := 0; ; {
|
||||
if r.zlibErr != nil {
|
||||
return numRead, r.zlibErr
|
||||
}
|
||||
if len(p) == 0 {
|
||||
return numRead, nil
|
||||
}
|
||||
|
||||
if r.i >= r.j {
|
||||
if r.readErr != nil {
|
||||
return numRead, r.readErr
|
||||
}
|
||||
|
||||
n, err := r.r.Read(r.buf[:])
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
r.i, r.j, r.readErr = 0, uint32(n), err
|
||||
continue
|
||||
}
|
||||
|
||||
e := C.cgozlib_inflate(&r.z, &r.a,
|
||||
(*C.Bytef)(unsafe.Pointer(&p[0])),
|
||||
(C.uInt)(len(p)),
|
||||
(*C.Bytef)(unsafe.Pointer(&r.buf[r.i])),
|
||||
(C.uInt)(r.j-r.i),
|
||||
)
|
||||
|
||||
numRead += int(r.a.ndst)
|
||||
p = p[int(r.a.ndst):]
|
||||
|
||||
r.i += uint32(r.a.nsrc)
|
||||
|
||||
if e == 0 {
|
||||
continue
|
||||
} else if e == errCodeStreamEnd {
|
||||
r.zlibErr = io.EOF
|
||||
} else if (e == errCodeNeedDict) && (len(r.dict) > 0) {
|
||||
e = C.cgozlib_inflateSetDictionary(&r.z,
|
||||
(*C.Bytef)(unsafe.Pointer(&r.dict[0])),
|
||||
(C.uInt)(len(r.dict)),
|
||||
)
|
||||
if e == 0 {
|
||||
continue
|
||||
}
|
||||
r.zlibErr = errCode(e)
|
||||
} else {
|
||||
r.zlibErr = errCode(e)
|
||||
}
|
||||
return numRead, r.zlibErr
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
// Copyright 2019 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package cgozlib
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// These examples come from the RAC spec.
|
||||
var (
|
||||
compressedMore = "\x78\x9c\x01\x06\x00\xf9\xff\x4d\x6f\x72\x65\x21" +
|
||||
"\x0a\x07\x42\x01\xbf"
|
||||
|
||||
compressedSheep = "\x78\xf9\x0b\xe0\x02\x6e\x0a\x29\xcf\x87\x31\x01\x01" +
|
||||
"\x00\x00\xff\xff\x18\x0c\x03\xa8"
|
||||
|
||||
dictSheep = []byte("\x20sheep.\n")
|
||||
)
|
||||
|
||||
type resetReadCloser interface {
|
||||
zlib.Resetter
|
||||
io.ReadCloser
|
||||
}
|
||||
|
||||
func makePure() resetReadCloser {
|
||||
r, err := zlib.NewReader(strings.NewReader(compressedMore))
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
return r.(resetReadCloser)
|
||||
}
|
||||
|
||||
func testReadAll(t *testing.T, r resetReadCloser, src io.Reader, dict []byte, want string) {
|
||||
t.Helper()
|
||||
|
||||
if err := r.Reset(src, dict); err != nil {
|
||||
t.Fatalf("Reset: %v", err)
|
||||
}
|
||||
|
||||
got, err := ioutil.ReadAll(r)
|
||||
if err != nil {
|
||||
t.Fatalf("ReadAll: %v", err)
|
||||
}
|
||||
|
||||
if err := r.Close(); err != nil {
|
||||
t.Fatalf("Close: %v", err)
|
||||
}
|
||||
|
||||
if string(got) != want {
|
||||
t.Fatalf("got %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func testReader(t *testing.T, r resetReadCloser) {
|
||||
testReadAll(t, r, strings.NewReader(compressedMore), nil, "More!\n")
|
||||
testReadAll(t, r, strings.NewReader(compressedSheep), dictSheep, "Two sheep.\n")
|
||||
testReadAll(t, r, strings.NewReader(compressedMore), nil, "More!\n")
|
||||
testReadAll(t, r, strings.NewReader(compressedSheep), dictSheep, "Two sheep.\n")
|
||||
}
|
||||
|
||||
func TestCgo(t *testing.T) { testReader(t, &Reader{}) }
|
||||
func TestPure(t *testing.T) { testReader(t, makePure()) }
|
||||
|
||||
func benchmarkReader(b *testing.B, r resetReadCloser) {
|
||||
src := bytes.NewReader(nil)
|
||||
srcBytes, err := ioutil.ReadFile("../../test/data/pi.txt.zlib")
|
||||
if err != nil {
|
||||
b.Fatalf("ReadFile: %v", err)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
src.Reset(srcBytes)
|
||||
|
||||
if err := r.Reset(src, nil); err != nil {
|
||||
b.Fatalf("Reset: %v", err)
|
||||
}
|
||||
|
||||
if n, err := io.Copy(ioutil.Discard, r); err != nil {
|
||||
b.Fatalf("Copy: %v", err)
|
||||
} else if n != 100003 {
|
||||
b.Fatalf("Copy: got %d, want %d", n, 100003)
|
||||
}
|
||||
|
||||
if err := r.Close(); err != nil {
|
||||
b.Fatalf("Close: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCgo(b *testing.B) { benchmarkReader(b, &Reader{}) }
|
||||
func BenchmarkPure(b *testing.B) { benchmarkReader(b, makePure()) }
|
||||
Reference in new issue
Block a user