← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/image/png/writer.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/image/png/writer.go
 
1
// Copyright 2009 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package png
 
6
 
 
7
import (
 
8
        "bufio"
 
9
        "compress/zlib"
 
10
        "hash/crc32"
 
11
        "image"
 
12
        "io"
 
13
        "os"
 
14
        "strconv"
 
15
)
 
16
 
 
17
type encoder struct {
 
18
        w      io.Writer
 
19
        m      image.Image
 
20
        cb     int
 
21
        err    os.Error
 
22
        header [8]byte
 
23
        footer [4]byte
 
24
        tmp    [3 * 256]byte
 
25
}
 
26
 
 
27
// Big-endian.
 
28
func writeUint32(b []uint8, u uint32) {
 
29
        b[0] = uint8(u >> 24)
 
30
        b[1] = uint8(u >> 16)
 
31
        b[2] = uint8(u >> 8)
 
32
        b[3] = uint8(u >> 0)
 
33
}
 
34
 
 
35
type opaquer interface {
 
36
        Opaque() bool
 
37
}
 
38
 
 
39
// Returns whether or not the image is fully opaque.
 
40
func opaque(m image.Image) bool {
 
41
        if o, ok := m.(opaquer); ok {
 
42
                return o.Opaque()
 
43
        }
 
44
        b := m.Bounds()
 
45
        for y := b.Min.Y; y < b.Max.Y; y++ {
 
46
                for x := b.Min.X; x < b.Max.X; x++ {
 
47
                        _, _, _, a := m.At(x, y).RGBA()
 
48
                        if a != 0xffff {
 
49
                                return false
 
50
                        }
 
51
                }
 
52
        }
 
53
        return true
 
54
}
 
55
 
 
56
// The absolute value of a byte interpreted as a signed int8.
 
57
func abs8(d uint8) int {
 
58
        if d < 128 {
 
59
                return int(d)
 
60
        }
 
61
        return 256 - int(d)
 
62
}
 
63
 
 
64
func (e *encoder) writeChunk(b []byte, name string) {
 
65
        if e.err != nil {
 
66
                return
 
67
        }
 
68
        n := uint32(len(b))
 
69
        if int(n) != len(b) {
 
70
                e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b)))
 
71
                return
 
72
        }
 
73
        writeUint32(e.header[0:4], n)
 
74
        e.header[4] = name[0]
 
75
        e.header[5] = name[1]
 
76
        e.header[6] = name[2]
 
77
        e.header[7] = name[3]
 
78
        crc := crc32.NewIEEE()
 
79
        crc.Write(e.header[4:8])
 
80
        crc.Write(b)
 
81
        writeUint32(e.footer[0:4], crc.Sum32())
 
82
 
 
83
        _, e.err = e.w.Write(e.header[0:8])
 
84
        if e.err != nil {
 
85
                return
 
86
        }
 
87
        _, e.err = e.w.Write(b)
 
88
        if e.err != nil {
 
89
                return
 
90
        }
 
91
        _, e.err = e.w.Write(e.footer[0:4])
 
92
}
 
93
 
 
94
func (e *encoder) writeIHDR() {
 
95
        b := e.m.Bounds()
 
96
        writeUint32(e.tmp[0:4], uint32(b.Dx()))
 
97
        writeUint32(e.tmp[4:8], uint32(b.Dy()))
 
98
        // Set bit depth and color type.
 
99
        switch e.cb {
 
100
        case cbG8:
 
101
                e.tmp[8] = 8
 
102
                e.tmp[9] = ctGrayscale
 
103
        case cbTC8:
 
104
                e.tmp[8] = 8
 
105
                e.tmp[9] = ctTrueColor
 
106
        case cbP8:
 
107
                e.tmp[8] = 8
 
108
                e.tmp[9] = ctPaletted
 
109
        case cbTCA8:
 
110
                e.tmp[8] = 8
 
111
                e.tmp[9] = ctTrueColorAlpha
 
112
        case cbG16:
 
113
                e.tmp[8] = 16
 
114
                e.tmp[9] = ctGrayscale
 
115
        case cbTC16:
 
116
                e.tmp[8] = 16
 
117
                e.tmp[9] = ctTrueColor
 
118
        case cbTCA16:
 
119
                e.tmp[8] = 16
 
120
                e.tmp[9] = ctTrueColorAlpha
 
121
        }
 
122
        e.tmp[10] = 0 // default compression method
 
123
        e.tmp[11] = 0 // default filter method
 
124
        e.tmp[12] = 0 // non-interlaced
 
125
        e.writeChunk(e.tmp[0:13], "IHDR")
 
126
}
 
127
 
 
128
func (e *encoder) writePLTE(p image.PalettedColorModel) {
 
129
        if len(p) < 1 || len(p) > 256 {
 
130
                e.err = FormatError("bad palette length: " + strconv.Itoa(len(p)))
 
131
                return
 
132
        }
 
133
        for i := 0; i < len(p); i++ {
 
134
                r, g, b, a := p[i].RGBA()
 
135
                if a != 0xffff {
 
136
                        e.err = UnsupportedError("non-opaque palette color")
 
137
                        return
 
138
                }
 
139
                e.tmp[3*i+0] = uint8(r >> 8)
 
140
                e.tmp[3*i+1] = uint8(g >> 8)
 
141
                e.tmp[3*i+2] = uint8(b >> 8)
 
142
        }
 
143
        e.writeChunk(e.tmp[0:3*len(p)], "PLTE")
 
144
}
 
145
 
 
146
// An encoder is an io.Writer that satisfies writes by writing PNG IDAT chunks,
 
147
// including an 8-byte header and 4-byte CRC checksum per Write call. Such calls
 
148
// should be relatively infrequent, since writeIDATs uses a bufio.Writer.
 
149
//
 
150
// This method should only be called from writeIDATs (via writeImage).
 
151
// No other code should treat an encoder as an io.Writer.
 
152
//
 
153
// Note that, because the zlib Reader may involve an io.Pipe, e.Write calls may
 
154
// occur on a separate go-routine than the e.writeIDATs call, and care should be
 
155
// taken that e's state (such as its tmp buffer) is not modified concurrently.
 
156
func (e *encoder) Write(b []byte) (int, os.Error) {
 
157
        e.writeChunk(b, "IDAT")
 
158
        if e.err != nil {
 
159
                return 0, e.err
 
160
        }
 
161
        return len(b), nil
 
162
}
 
163
 
 
164
// Chooses the filter to use for encoding the current row, and applies it.
 
165
// The return value is the index of the filter and also of the row in cr that has had it applied.
 
166
func filter(cr [][]byte, pr []byte, bpp int) int {
 
167
        // We try all five filter types, and pick the one that minimizes the sum of absolute differences.
 
168
        // This is the same heuristic that libpng uses, although the filters are attempted in order of
 
169
        // estimated most likely to be minimal (ftUp, ftPaeth, ftNone, ftSub, ftAverage), rather than
 
170
        // in their enumeration order (ftNone, ftSub, ftUp, ftAverage, ftPaeth).
 
171
        cdat0 := cr[0][1:]
 
172
        cdat1 := cr[1][1:]
 
173
        cdat2 := cr[2][1:]
 
174
        cdat3 := cr[3][1:]
 
175
        cdat4 := cr[4][1:]
 
176
        pdat := pr[1:]
 
177
        n := len(cdat0)
 
178
 
 
179
        // The up filter.
 
180
        sum := 0
 
181
        for i := 0; i < n; i++ {
 
182
                cdat2[i] = cdat0[i] - pdat[i]
 
183
                sum += abs8(cdat2[i])
 
184
        }
 
185
        best := sum
 
186
        filter := ftUp
 
187
 
 
188
        // The Paeth filter.
 
189
        sum = 0
 
190
        for i := 0; i < bpp; i++ {
 
191
                cdat4[i] = cdat0[i] - paeth(0, pdat[i], 0)
 
192
                sum += abs8(cdat4[i])
 
193
        }
 
194
        for i := bpp; i < n; i++ {
 
195
                cdat4[i] = cdat0[i] - paeth(cdat0[i-bpp], pdat[i], pdat[i-bpp])
 
196
                sum += abs8(cdat4[i])
 
197
                if sum >= best {
 
198
                        break
 
199
                }
 
200
        }
 
201
        if sum < best {
 
202
                best = sum
 
203
                filter = ftPaeth
 
204
        }
 
205
 
 
206
        // The none filter.
 
207
        sum = 0
 
208
        for i := 0; i < n; i++ {
 
209
                sum += abs8(cdat0[i])
 
210
                if sum >= best {
 
211
                        break
 
212
                }
 
213
        }
 
214
        if sum < best {
 
215
                best = sum
 
216
                filter = ftNone
 
217
        }
 
218
 
 
219
        // The sub filter.
 
220
        sum = 0
 
221
        for i := 0; i < bpp; i++ {
 
222
                cdat1[i] = cdat0[i]
 
223
                sum += abs8(cdat1[i])
 
224
        }
 
225
        for i := bpp; i < n; i++ {
 
226
                cdat1[i] = cdat0[i] - cdat0[i-bpp]
 
227
                sum += abs8(cdat1[i])
 
228
                if sum >= best {
 
229
                        break
 
230
                }
 
231
        }
 
232
        if sum < best {
 
233
                best = sum
 
234
                filter = ftSub
 
235
        }
 
236
 
 
237
        // The average filter.
 
238
        sum = 0
 
239
        for i := 0; i < bpp; i++ {
 
240
                cdat3[i] = cdat0[i] - pdat[i]/2
 
241
                sum += abs8(cdat3[i])
 
242
        }
 
243
        for i := bpp; i < n; i++ {
 
244
                cdat3[i] = cdat0[i] - uint8((int(cdat0[i-bpp])+int(pdat[i]))/2)
 
245
                sum += abs8(cdat3[i])
 
246
                if sum >= best {
 
247
                        break
 
248
                }
 
249
        }
 
250
        if sum < best {
 
251
                best = sum
 
252
                filter = ftAverage
 
253
        }
 
254
 
 
255
        return filter
 
256
}
 
257
 
 
258
func writeImage(w io.Writer, m image.Image, cb int) os.Error {
 
259
        zw, err := zlib.NewWriter(w)
 
260
        if err != nil {
 
261
                return err
 
262
        }
 
263
        defer zw.Close()
 
264
 
 
265
        bpp := 0 // Bytes per pixel.
 
266
        var paletted *image.Paletted
 
267
        switch cb {
 
268
        case cbG8:
 
269
                bpp = 1
 
270
        case cbTC8:
 
271
                bpp = 3
 
272
        case cbP8:
 
273
                bpp = 1
 
274
                paletted = m.(*image.Paletted)
 
275
        case cbTCA8:
 
276
                bpp = 4
 
277
        case cbTC16:
 
278
                bpp = 6
 
279
        case cbTCA16:
 
280
                bpp = 8
 
281
        case cbG16:
 
282
                bpp = 2
 
283
        }
 
284
        // cr[*] and pr are the bytes for the current and previous row.
 
285
        // cr[0] is unfiltered (or equivalently, filtered with the ftNone filter).
 
286
        // cr[ft], for non-zero filter types ft, are buffers for transforming cr[0] under the
 
287
        // other PNG filter types. These buffers are allocated once and re-used for each row.
 
288
        // The +1 is for the per-row filter type, which is at cr[*][0].
 
289
        b := m.Bounds()
 
290
        var cr [nFilter][]uint8
 
291
        for i := 0; i < len(cr); i++ {
 
292
                cr[i] = make([]uint8, 1+bpp*b.Dx())
 
293
                cr[i][0] = uint8(i)
 
294
        }
 
295
        pr := make([]uint8, 1+bpp*b.Dx())
 
296
 
 
297
        for y := b.Min.Y; y < b.Max.Y; y++ {
 
298
                // Convert from colors to bytes.
 
299
                switch cb {
 
300
                case cbG8:
 
301
                        for x := b.Min.X; x < b.Max.X; x++ {
 
302
                                c := image.GrayColorModel.Convert(m.At(x, y)).(image.GrayColor)
 
303
                                cr[0][x+1] = c.Y
 
304
                        }
 
305
                case cbTC8:
 
306
                        for x := b.Min.X; x < b.Max.X; x++ {
 
307
                                // We have previously verified that the alpha value is fully opaque.
 
308
                                r, g, b, _ := m.At(x, y).RGBA()
 
309
                                cr[0][3*x+1] = uint8(r >> 8)
 
310
                                cr[0][3*x+2] = uint8(g >> 8)
 
311
                                cr[0][3*x+3] = uint8(b >> 8)
 
312
                        }
 
313
                case cbP8:
 
314
                        rowOffset := y * paletted.Stride
 
315
                        copy(cr[0][b.Min.X+1:], paletted.Pix[rowOffset+b.Min.X:rowOffset+b.Max.X])
 
316
                case cbTCA8:
 
317
                        // Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied.
 
318
                        for x := b.Min.X; x < b.Max.X; x++ {
 
319
                                c := image.NRGBAColorModel.Convert(m.At(x, y)).(image.NRGBAColor)
 
320
                                cr[0][4*x+1] = c.R
 
321
                                cr[0][4*x+2] = c.G
 
322
                                cr[0][4*x+3] = c.B
 
323
                                cr[0][4*x+4] = c.A
 
324
                        }
 
325
                case cbG16:
 
326
                        for x := b.Min.X; x < b.Max.X; x++ {
 
327
                                c := image.Gray16ColorModel.Convert(m.At(x, y)).(image.Gray16Color)
 
328
                                cr[0][2*x+1] = uint8(c.Y >> 8)
 
329
                                cr[0][2*x+2] = uint8(c.Y)
 
330
                        }
 
331
                case cbTC16:
 
332
                        for x := b.Min.X; x < b.Max.X; x++ {
 
333
                                // We have previously verified that the alpha value is fully opaque.
 
334
                                r, g, b, _ := m.At(x, y).RGBA()
 
335
                                cr[0][6*x+1] = uint8(r >> 8)
 
336
                                cr[0][6*x+2] = uint8(r)
 
337
                                cr[0][6*x+3] = uint8(g >> 8)
 
338
                                cr[0][6*x+4] = uint8(g)
 
339
                                cr[0][6*x+5] = uint8(b >> 8)
 
340
                                cr[0][6*x+6] = uint8(b)
 
341
                        }
 
342
                case cbTCA16:
 
343
                        // Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied.
 
344
                        for x := b.Min.X; x < b.Max.X; x++ {
 
345
                                c := image.NRGBA64ColorModel.Convert(m.At(x, y)).(image.NRGBA64Color)
 
346
                                cr[0][8*x+1] = uint8(c.R >> 8)
 
347
                                cr[0][8*x+2] = uint8(c.R)
 
348
                                cr[0][8*x+3] = uint8(c.G >> 8)
 
349
                                cr[0][8*x+4] = uint8(c.G)
 
350
                                cr[0][8*x+5] = uint8(c.B >> 8)
 
351
                                cr[0][8*x+6] = uint8(c.B)
 
352
                                cr[0][8*x+7] = uint8(c.A >> 8)
 
353
                                cr[0][8*x+8] = uint8(c.A)
 
354
                        }
 
355
                }
 
356
 
 
357
                // Apply the filter.
 
358
                f := filter(cr[0:nFilter], pr, bpp)
 
359
 
 
360
                // Write the compressed bytes.
 
361
                _, err = zw.Write(cr[f])
 
362
                if err != nil {
 
363
                        return err
 
364
                }
 
365
 
 
366
                // The current row for y is the previous row for y+1.
 
367
                pr, cr[0] = cr[0], pr
 
368
        }
 
369
        return nil
 
370
}
 
371
 
 
372
// Write the actual image data to one or more IDAT chunks.
 
373
func (e *encoder) writeIDATs() {
 
374
        if e.err != nil {
 
375
                return
 
376
        }
 
377
        var bw *bufio.Writer
 
378
        bw, e.err = bufio.NewWriterSize(e, 1<<15)
 
379
        if e.err != nil {
 
380
                return
 
381
        }
 
382
        e.err = writeImage(bw, e.m, e.cb)
 
383
        if e.err != nil {
 
384
                return
 
385
        }
 
386
        e.err = bw.Flush()
 
387
}
 
388
 
 
389
func (e *encoder) writeIEND() { e.writeChunk(e.tmp[0:0], "IEND") }
 
390
 
 
391
// Encode writes the Image m to w in PNG format. Any Image may be encoded, but
 
392
// images that are not image.NRGBA might be encoded lossily.
 
393
func Encode(w io.Writer, m image.Image) os.Error {
 
394
        // Obviously, negative widths and heights are invalid. Furthermore, the PNG
 
395
        // spec section 11.2.2 says that zero is invalid. Excessively large images are
 
396
        // also rejected.
 
397
        mw, mh := int64(m.Bounds().Dx()), int64(m.Bounds().Dy())
 
398
        if mw <= 0 || mh <= 0 || mw >= 1<<32 || mh >= 1<<32 {
 
399
                return FormatError("invalid image size: " + strconv.Itoa64(mw) + "x" + strconv.Itoa64(mw))
 
400
        }
 
401
 
 
402
        var e encoder
 
403
        e.w = w
 
404
        e.m = m
 
405
        pal, _ := m.(*image.Paletted)
 
406
        if pal != nil {
 
407
                e.cb = cbP8
 
408
        } else {
 
409
                switch m.ColorModel() {
 
410
                case image.GrayColorModel:
 
411
                        e.cb = cbG8
 
412
                case image.Gray16ColorModel:
 
413
                        e.cb = cbG16
 
414
                case image.RGBAColorModel, image.NRGBAColorModel, image.AlphaColorModel:
 
415
                        if opaque(m) {
 
416
                                e.cb = cbTC8
 
417
                        } else {
 
418
                                e.cb = cbTCA8
 
419
                        }
 
420
                default:
 
421
                        if opaque(m) {
 
422
                                e.cb = cbTC16
 
423
                        } else {
 
424
                                e.cb = cbTCA16
 
425
                        }
 
426
                }
 
427
        }
 
428
 
 
429
        _, e.err = io.WriteString(w, pngHeader)
 
430
        e.writeIHDR()
 
431
        if pal != nil {
 
432
                e.writePLTE(pal.Palette)
 
433
        }
 
434
        e.writeIDATs()
 
435
        e.writeIEND()
 
436
        return e.err
 
437
}