335 lines
7.5 KiB
Go
335 lines
7.5 KiB
Go
// Copyright 2020 Google LLC
|
|
//
|
|
// 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
|
|
//
|
|
// http://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 pdf implements a minimal PDF 1.7 writer, just functional enough to
|
|
// create a PDF file containing a QR code encoded as rectangles.
|
|
//
|
|
// It follows the standard “PDF 32000-1:2008 PDF 1.7”:
|
|
// https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/PDF32000_2008.pdf
|
|
package pdf
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func dateString(t time.Time) string {
|
|
return "D:" + t.Format("20060102150405-07'00'")
|
|
}
|
|
|
|
// ObjectID is a PDF object id.
|
|
type ObjectID int
|
|
|
|
// String implements fmt.Stringer.
|
|
func (o ObjectID) String() string {
|
|
return fmt.Sprintf("%d 0 R", int(o))
|
|
}
|
|
|
|
// Object is implemented by all PDF objects.
|
|
type Object interface {
|
|
// Objects returns all Objects which should be encoded into the
|
|
// PDF file.
|
|
Objects() []Object
|
|
|
|
// Encode encodes the object into the PDF file w.
|
|
Encode(w io.Writer, ids map[string]ObjectID) error
|
|
|
|
// SetID updates the object id.
|
|
SetID(id ObjectID)
|
|
|
|
// Name returns the human-readable object name.
|
|
Name() string
|
|
|
|
fmt.Stringer
|
|
}
|
|
|
|
// Common represents a PDF object.
|
|
type Common struct {
|
|
ObjectName string
|
|
ID ObjectID
|
|
Stream []byte
|
|
}
|
|
|
|
// String implements fmt.Stringer.
|
|
func (c *Common) String() string {
|
|
return c.ID.String()
|
|
}
|
|
|
|
// SetID implements Object.
|
|
func (c *Common) SetID(id ObjectID) {
|
|
c.ID = id
|
|
}
|
|
|
|
// Name implements Object.
|
|
func (c *Common) Name() string {
|
|
return c.ObjectName
|
|
}
|
|
|
|
// Objects implements Object.
|
|
func (c *Common) Objects() []Object {
|
|
return []Object{c}
|
|
}
|
|
|
|
// Encode implements Object.
|
|
func (c *Common) Encode(w io.Writer, ids map[string]ObjectID) error {
|
|
_, err := fmt.Fprintf(w, `
|
|
%d 0 obj
|
|
<<
|
|
/Length %d
|
|
>>
|
|
stream
|
|
%s
|
|
endstream
|
|
endobj`, c.ID, len(c.Stream), c.Stream)
|
|
return err
|
|
}
|
|
|
|
// DocumentInfo represents a PDF document information object.
|
|
type DocumentInfo struct {
|
|
Common
|
|
|
|
CreationDate time.Time
|
|
Producer string
|
|
Title string
|
|
}
|
|
|
|
// Objects implements Object.
|
|
func (d *DocumentInfo) Objects() []Object {
|
|
return []Object{d}
|
|
}
|
|
|
|
// Encode implements Object.
|
|
func (d *DocumentInfo) Encode(w io.Writer, ids map[string]ObjectID) error {
|
|
_, err := fmt.Fprintf(w, `
|
|
%d 0 obj
|
|
<<
|
|
/Title (%s)
|
|
/CreationDate (%s)
|
|
/ModDate (%s)
|
|
/Producer (%s)
|
|
>>
|
|
endobj`,
|
|
int(d.ID),
|
|
d.Title,
|
|
dateString(d.CreationDate),
|
|
dateString(d.CreationDate),
|
|
d.Producer)
|
|
return err
|
|
}
|
|
|
|
// Catalog represents a PDF catalog object.
|
|
type Catalog struct {
|
|
Common
|
|
Pages Object // Pages
|
|
}
|
|
|
|
// Objects implements Object.
|
|
func (r *Catalog) Objects() []Object {
|
|
return append([]Object{r}, r.Pages.Objects()...)
|
|
}
|
|
|
|
// Encode implements Object.
|
|
func (r *Catalog) Encode(w io.Writer, ids map[string]ObjectID) error {
|
|
_, err := fmt.Fprintf(w, `
|
|
%d 0 obj
|
|
<<
|
|
/Type /Catalog
|
|
/Pages %v
|
|
>>
|
|
endobj`, int(r.ID), r.Pages)
|
|
return err
|
|
}
|
|
|
|
// Pages represents a PDF pages object
|
|
type Pages struct {
|
|
Common
|
|
Kids []Object // Page
|
|
}
|
|
|
|
// Objects implements Object.
|
|
func (p *Pages) Objects() []Object {
|
|
result := []Object{p}
|
|
for _, o := range p.Kids {
|
|
result = append(result, o.Objects()...)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Encode implements Object.
|
|
func (p *Pages) Encode(w io.Writer, ids map[string]ObjectID) error {
|
|
_, err := fmt.Fprintf(w, `
|
|
%d 0 obj
|
|
<<
|
|
/Kids %v
|
|
/Type /Pages
|
|
/Count %d
|
|
>>
|
|
endobj`, int(p.ID), p.Kids, len(p.Kids))
|
|
return err
|
|
}
|
|
|
|
// Page represents a PDF page object with size DIN A4
|
|
type Page struct {
|
|
Common
|
|
|
|
Resources []Object // Image
|
|
Contents []Object // Common (streams)
|
|
|
|
// Parent contains the human-readable name of the parent object,
|
|
// which will be translated into an object ID when encoding.
|
|
Parent string
|
|
}
|
|
|
|
// Objects implements Object.
|
|
func (p *Page) Objects() []Object {
|
|
result := []Object{p}
|
|
for _, o := range p.Resources {
|
|
result = append(result, o.Objects()...)
|
|
}
|
|
for _, o := range p.Contents {
|
|
result = append(result, o.Objects()...)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Encode implements Object.
|
|
func (p *Page) Encode(w io.Writer, ids map[string]ObjectID) error {
|
|
xObjects := make([]string, len(p.Resources))
|
|
for idx, o := range p.Resources {
|
|
xObjects[idx] = fmt.Sprintf("/%s %v", o.Name(), ids[o.Name()])
|
|
}
|
|
_, err := fmt.Fprintf(w, `
|
|
%d 0 obj
|
|
<<
|
|
/Resources <<
|
|
/XObject <<
|
|
%s
|
|
>>
|
|
>>
|
|
/Contents %v
|
|
/Parent %v
|
|
/Type /Page
|
|
/MediaBox [ 0 0 152 152 ]
|
|
>>
|
|
endobj`, int(p.ID), strings.Join(xObjects, "\n"), p.Contents, ids[p.Parent])
|
|
return err
|
|
}
|
|
|
|
type countingWriter struct {
|
|
cnt int
|
|
w io.Writer
|
|
}
|
|
|
|
func (cw *countingWriter) Write(p []byte) (n int, err error) {
|
|
n, err = cw.w.Write(p)
|
|
cw.cnt += n
|
|
return n, err
|
|
}
|
|
|
|
// Encoder is a PDF writer.
|
|
type Encoder struct {
|
|
w *countingWriter
|
|
}
|
|
|
|
// NewEncoder returns a ready-to-use Encoder writing to w.
|
|
func NewEncoder(w io.Writer) *Encoder {
|
|
return &Encoder{
|
|
w: &countingWriter{w: w},
|
|
}
|
|
}
|
|
|
|
// writeXrefTable writes a cross-reference table to e.w. See also “PDF
|
|
// 32000-1:2008 PDF 1.7” section “7.5.4 Cross-Reference Table”
|
|
func (e *Encoder) writeXrefTable(Objects []Object, xrefOffsets []int) error {
|
|
if _, err := fmt.Fprintf(e.w, "\nxref\n0 %d\n", len(Objects)+1); err != nil {
|
|
return err
|
|
}
|
|
|
|
// index 0 can never point to a valid Object, so print an invalid entry:
|
|
if _, err := fmt.Fprintf(e.w, "%010d %05d %s \n", 0, 65535, "f"); err != nil {
|
|
return err
|
|
}
|
|
|
|
const generation = 0
|
|
for _, offset := range xrefOffsets {
|
|
if _, err := fmt.Fprintf(e.w, "%010d %05d %s \n", offset, generation, "n"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Encode writes the PDF file represented by the specified catalog.
|
|
func (e *Encoder) Encode(r *Catalog, info *DocumentInfo) error {
|
|
// As per “PDF Explained: How a PDF File is Written”:
|
|
// https://www.geekbooks.me/book/view/pdf-explained
|
|
|
|
// (1.) Output the header.
|
|
|
|
// Byte sequence 0xE2E3CFD3 as per the recommendation from
|
|
// “Developing with PDF”. See “Chapter 1. PDF Syntax”:
|
|
// https://www.safaribooksonline.com/library/view/developing-with-pdf/9781449327903/ch01.html#_header
|
|
if _, err := e.w.Write(append([]byte("%PDF-1.4\n%"), 0xe2, 0xe3, 0xcf, 0xd3)); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Flatten the Object graph into a slice
|
|
objects := append(r.Objects(), info.Objects()...)
|
|
|
|
// (3.) Assign ids from 1 to n and store them in a lookup table
|
|
// (some Objects need to resolve name references when encoding).
|
|
ids := make(map[string]ObjectID, len(objects))
|
|
for idx, obj := range objects {
|
|
id := ObjectID(idx + 1)
|
|
obj.SetID(id)
|
|
ids[obj.Name()] = id
|
|
}
|
|
|
|
// (4.) Output the Objects one by one, starting with Object number
|
|
// one, recording the byte offset of each for the cross-reference
|
|
// table.
|
|
xrefOffsets := make([]int, len(objects))
|
|
for idx, obj := range objects {
|
|
xrefOffsets[idx] = e.w.cnt + 1
|
|
if err := obj.Encode(e.w, ids); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// (5.) Write the cross-reference table.
|
|
xrefOffset := e.w.cnt
|
|
|
|
if err := e.writeXrefTable(objects, xrefOffsets); err != nil {
|
|
return err
|
|
}
|
|
|
|
// (6.) Write the trailer, trailer dictionary, and end-of-file marker.
|
|
if _, err := fmt.Fprintf(e.w, `trailer
|
|
<<
|
|
/Root %v
|
|
/Size %d
|
|
/Info %v
|
|
>>
|
|
startxref
|
|
%d
|
|
%%%%EOF
|
|
`, ids["catalog"], len(objects)+1, ids["info"], xrefOffset); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|