func loadFont(f *fontdata) (font *FontMetrics) {
var err error
if font, err = ParseFontMetricsFile(f.Metrics, f.Label); err != nil {
log.Fatalf("loading font metrics: %v", err)
}
if f.StemV > 0 && font.StemV <= 0 {
font.StemV = f.StemV
}
if len(f.FontFile) > 0 {
font.File = []byte(f.FontFile)
var buf bytes.Buffer
var writer *zlib.Writer
if writer, err = zlib.NewWriterLevel(&buf, zlib.BestCompression); err != nil {
log.Fatal("Setting up zlib compressor: ", err)
}
if _, err = writer.Write(font.File); err != nil {
log.Fatal("Writing to zlib compressor: ", err)
}
if err = writer.Close(); err != nil {
log.Fatal("Closing zlib compressor: ", err)
}
font.CompressedFile = buf.Bytes()
}
return
}
func (self *ZlibCompressor) Compress(src []byte) ([]byte, error) {
var err error
var compressor *zlib.Writer
cdest := bytes.NewBuffer(make([]byte, 0, len(src)))
if self.dict == nil {
compressor, err = zlib.NewWriterLevel(cdest, self.level)
} else {
compressor, err = zlib.NewWriterLevelDict(cdest, self.level, self.dict)
}
compressor.Write(src)
err = compressor.Close()
if err != nil {
fmt.Println("Compress Close err:%s", err.Error())
}
return cdest.Bytes(), err
}
// createCompressedPacket generates a compressed protocol packet after
// compressing the specified payload.
func (rw *compressRW) createCompressedPacket(payload []byte) ([]byte, error) {
var (
w *zlib.Writer
z bytes.Buffer
packet []byte
err error
payloadLength int
)
// TODO: add a property for compression level
if w, err = zlib.NewWriterLevel(&z, zlib.DefaultCompression); err != nil {
goto E
}
if _, err = w.Write(payload); err != nil {
goto E
}
if err = w.Close(); err != nil {
goto E
}
payloadLength = z.Len()
// allocate buffer for the compressed packet
// header (7 bytes) + payload
packet = make([]byte, 7+payloadLength)
// compressed header
// - size of compressed payload
putUint24(packet[0:3], uint32(payloadLength))
// - packet sequence number
packet[3] = rw.seqno
// - size of payload before it was compressed
putUint24(packet[4:7], uint32(len(payload)))
// copy the compressed payload
copy(packet[7:], z.Bytes())
return packet, nil
E:
return nil, myError(ErrCompression, err)
}
func (stream *PDFStream) Render(indent string, out io.Writer) (err error) {
if CompressStreams && len(stream.Compressed) == 0 {
// compress the stream contents
var buf bytes.Buffer
var writer *zlib.Writer
if writer, err = zlib.NewWriterLevel(&buf, zlib.BestCompression); err != nil {
return
}
if _, err = writer.Write(stream.Data); err != nil {
return
}
if err = writer.Close(); err != nil {
return
}
stream.Compressed = buf.Bytes()
}
if CompressStreams {
stream.Map["Filter"] = PDFName("FlateDecode")
stream.Map["Length"] = PDFNumber(len(stream.Compressed))
} else {
stream.Map["Length"] = PDFNumber(len(stream.Data))
}
if err = stream.Map.Render(indent, out); err != nil {
return
}
fmt.Fprint(out, "\nstream\n")
if CompressStreams {
if _, err = out.Write(stream.Compressed); err != nil {
return
}
} else {
if _, err = out.Write(stream.Data); err != nil {
return
}
}
fmt.Fprint(out, "endstream")
return
}
func (pp *pendingPayload) Generate() (err error) {
var buffer bytes.Buffer
// Assertion
if len(pp.events) == 0 {
return ErrPayloadCorrupt
}
// Begin with the nonce
if _, err = buffer.Write([]byte(pp.nonce)[0:16]); err != nil {
return
}
var compressor *zlib.Writer
if compressor, err = zlib.NewWriterLevel(&buffer, 3); err != nil {
return
}
// Append all the events
for _, event := range pp.events[pp.ack_events:] {
if err = binary.Write(compressor, binary.BigEndian, uint32(len(event.Event))); err != nil {
return
}
if _, err = compressor.Write(event.Event); err != nil {
return
}
}
compressor.Close()
pp.payload = buffer.Bytes()
pp.last_sequence = 0
pp.sequence_len = len(pp.events) - pp.ack_events
return
}
