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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
package processor
import (
"fmt"
"image"
"image/gif"
"image/jpeg"
"image/png"
"os"
"path/filepath"
"time"
"codeberg.org/snonux/snonux/internal/post"
"golang.org/x/image/draw"
)
const (
maxImageWidth = 1024
jpegQuality = 80
)
type imageBuilder struct{}
func (imageBuilder) Plan(srcPath string, ext string) (postPlan, error) {
plan := postPlan{srcPath: srcPath, ext: ext}
img, err := validateImage(srcPath)
if err != nil {
return postPlan{}, err
}
plan.validatedImage = img
return plan, nil
}
func (imageBuilder) Commit(plan postPlan, postDir string, id string, now time.Time) (*post.Post, []string, error) {
if err := writeImageAsset(plan.validatedImage, postDir); err != nil {
return nil, nil, err
}
src := fmt.Sprintf("posts/%s/image.jpg", id)
html := fmt.Sprintf(`<img src="%s" alt="" class="post-image">`, src)
p := &post.Post{
ID: id,
Timestamp: now,
PostType: post.TypeImage,
Content: html,
Assets: []string{"image.jpg"},
}
return p, nil, nil
}
func init() {
register(".png", imageBuilder{})
register(".jpg", imageBuilder{})
register(".jpeg", imageBuilder{})
register(".gif", imageBuilder{})
}
// validateImage reads and decodes the source image, resizing if necessary.
// It performs only read validation; the caller is responsible for writing assets.
func validateImage(srcPath string) (image.Image, error) {
img, err := decodeImage(srcPath)
if err != nil {
return nil, err
}
return resizeIfNeeded(img), nil
}
// writeImageAsset writes the prepared image as JPEG into postDir.
func writeImageAsset(img image.Image, postDir string) error {
outPath := filepath.Join(postDir, "image.jpg")
return writeJPEG(img, outPath)
}
// decodeImage decodes a JPEG, PNG, or GIF (first frame) from srcPath.
// It sniffs the actual file type from magic bytes instead of trusting the extension.
func decodeImage(srcPath string) (image.Image, error) {
f, err := os.Open(srcPath)
if err != nil {
return nil, fmt.Errorf("open image %s: %w", srcPath, err)
}
defer f.Close()
// Read the first 512 bytes to detect the actual file format.
const sniffLen = 512
head := make([]byte, sniffLen)
n, err := f.Read(head)
if err != nil {
return nil, fmt.Errorf("read image %s: %w", srcPath, err)
}
if n == 0 {
return nil, fmt.Errorf("empty image file: %s", srcPath)
}
// Determine the actual image format from magic bytes.
sniff := head[:n]
var format string
switch {
case len(sniff) >= 2 && sniff[0] == 0xFF && sniff[1] == 0xD8:
format = "jpeg"
case len(sniff) >= 8 && string(sniff[:8]) == "\x89PNG\r\n\x1a\n":
format = "png"
case len(sniff) >= 6 && string(sniff[:6]) == "GIF87a" || string(sniff[:6]) == "GIF89a":
format = "gif"
default:
return nil, fmt.Errorf("unsupported image format for %s (extension: %s sniff: %q)", srcPath, filepath.Ext(srcPath), string(sniff))
}
// Rewind to the beginning so the decoder sees the full stream.
if _, err := f.Seek(0, 0); err != nil {
return nil, fmt.Errorf("rewind image %s: %w", srcPath, err)
}
var img image.Image
var decodeErr error
switch format {
case "jpeg":
img, decodeErr = jpeg.Decode(f)
if decodeErr != nil {
return nil, fmt.Errorf("decode JPEG %s: %w", srcPath, decodeErr)
}
case "png":
img, decodeErr = png.Decode(f)
if decodeErr != nil {
return nil, fmt.Errorf("decode PNG %s: %w", srcPath, decodeErr)
}
case "gif":
// Use only the first frame of animated GIFs.
img, decodeErr = gif.Decode(f)
if decodeErr != nil {
return nil, fmt.Errorf("decode GIF %s: %w", srcPath, decodeErr)
}
}
return img, nil
}
// resizeIfNeeded returns a resized copy of img if its width exceeds maxImageWidth,
// preserving aspect ratio. Otherwise the original is returned unchanged.
func resizeIfNeeded(img image.Image) image.Image {
bounds := img.Bounds()
w := bounds.Dx()
if w <= maxImageWidth {
return img
}
h := bounds.Dy()
newW := maxImageWidth
newH := (h * newW) / w
dst := image.NewRGBA(image.Rect(0, 0, newW, newH))
draw.BiLinear.Scale(dst, dst.Bounds(), img, bounds, draw.Over, nil)
return dst
}
// writeJPEG encodes img as JPEG at the configured quality level and writes to path.
func writeJPEG(img image.Image, path string) error {
f, err := os.Create(path)
if err != nil {
return fmt.Errorf("create JPEG %s: %w", path, err)
}
defer f.Close()
opts := &jpeg.Options{Quality: jpegQuality}
if err := jpeg.Encode(f, img, opts); err != nil {
return fmt.Errorf("encode JPEG %s: %w", path, err)
}
return nil
}
|
