-
Notifications
You must be signed in to change notification settings - Fork 101
/
pdf_optimize.go
116 lines (98 loc) · 2.6 KB
/
pdf_optimize.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
/*
* PDF optimization (compression) example.
*
* Run as: go run pdf_optimize.go <input.pdf> <output.pdf>
*/
package main
import (
"fmt"
"log"
"os"
"time"
"github.com/unidoc/unipdf/v3/model"
"github.com/unidoc/unipdf/v3/model/optimize"
)
const usage = "Usage: %s INPUT_PDF_PATH OUTPUT_PDF_PATH\n"
func main() {
args := os.Args
if len(args) < 3 {
fmt.Printf(usage, os.Args[0])
return
}
inputPath := args[1]
outputPath := args[2]
// Initialize starting time.
start := time.Now()
// Get input file stat.
inputFileInfo, err := os.Stat(inputPath)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
// Create reader.
inputFile, err := os.Open(inputPath)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
defer inputFile.Close()
reader, err := model.NewPdfReader(inputFile)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
// Get number of pages in the input file.
pages, err := reader.GetNumPages()
if err != nil {
log.Fatal("Fail: %v\n", err)
}
// Add input file pages to the writer.
writer := model.NewPdfWriter()
for i := 1; i <= pages; i++ {
page, err := reader.GetPage(i)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
if err = writer.AddPage(page); err != nil {
log.Fatal("Fail: %v\n", err)
}
}
// Add reader AcroForm to the writer.
if reader.AcroForm != nil {
writer.SetForms(reader.AcroForm)
}
// Set optimizer.
writer.SetOptimizer(optimize.New(optimize.Options{
CombineDuplicateDirectObjects: true,
CombineIdenticalIndirectObjects: true,
CombineDuplicateStreams: true,
CompressStreams: true,
UseObjectStreams: true,
ImageQuality: 80,
ImageUpperPPI: 100,
}))
// Create output file.
outputFile, err := os.Create(outputPath)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
defer outputFile.Close()
// Write output file.
err = writer.Write(outputFile)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
// Get output file stat.
outputFileInfo, err := os.Stat(outputPath)
if err != nil {
log.Fatal("Fail: %v\n", err)
}
// Print basic optimization statistics.
inputSize := inputFileInfo.Size()
outputSize := outputFileInfo.Size()
ratio := 100.0 - (float64(outputSize) / float64(inputSize) * 100.0)
duration := float64(time.Since(start)) / float64(time.Millisecond)
fmt.Printf("Original file: %s\n", inputPath)
fmt.Printf("Original size: %d bytes\n", inputSize)
fmt.Printf("Optimized file: %s\n", outputPath)
fmt.Printf("Optimized size: %d bytes\n", outputSize)
fmt.Printf("Compression ratio: %.2f%%\n", ratio)
fmt.Printf("Processing time: %.2f ms\n", duration)
}