| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package png |
| |
| import ( |
| "bufio" |
| "compress/zlib" |
| "encoding/binary" |
| "hash/crc32" |
| "image" |
| "image/color" |
| "io" |
| "strconv" |
| ) |
| |
| // Encoder configures encoding PNG images. |
| type Encoder struct { |
| CompressionLevel CompressionLevel |
| |
| // BufferPool optionally specifies a buffer pool to get temporary |
| // EncoderBuffers when encoding an image. |
| BufferPool EncoderBufferPool |
| } |
| |
| // EncoderBufferPool is an interface for getting and returning temporary |
| // instances of the EncoderBuffer struct. This can be used to reuse buffers |
| // when encoding multiple images. |
| type EncoderBufferPool interface { |
| Get() *EncoderBuffer |
| Put(*EncoderBuffer) |
| } |
| |
| // EncoderBuffer holds the buffers used for encoding PNG images. |
| type EncoderBuffer encoder |
| |
| type encoder struct { |
| enc *Encoder |
| w io.Writer |
| m image.Image |
| cb int |
| err error |
| header [8]byte |
| footer [4]byte |
| tmp [4 * 256]byte |
| cr [nFilter][]uint8 |
| pr []uint8 |
| zw *zlib.Writer |
| zwLevel int |
| bw *bufio.Writer |
| } |
| |
| type CompressionLevel int |
| |
| const ( |
| DefaultCompression CompressionLevel = 0 |
| NoCompression CompressionLevel = -1 |
| BestSpeed CompressionLevel = -2 |
| BestCompression CompressionLevel = -3 |
| |
| // Positive CompressionLevel values are reserved to mean a numeric zlib |
| // compression level, although that is not implemented yet. |
| ) |
| |
| type opaquer interface { |
| Opaque() bool |
| } |
| |
| // Returns whether or not the image is fully opaque. |
| func opaque(m image.Image) bool { |
| if o, ok := m.(opaquer); ok { |
| return o.Opaque() |
| } |
| b := m.Bounds() |
| for y := b.Min.Y; y < b.Max.Y; y++ { |
| for x := b.Min.X; x < b.Max.X; x++ { |
| _, _, _, a := m.At(x, y).RGBA() |
| if a != 0xffff { |
| return false |
| } |
| } |
| } |
| return true |
| } |
| |
| // The absolute value of a byte interpreted as a signed int8. |
| func abs8(d uint8) int { |
| if d < 128 { |
| return int(d) |
| } |
| return 256 - int(d) |
| } |
| |
| func (e *encoder) writeChunk(b []byte, name string) { |
| if e.err != nil { |
| return |
| } |
| n := uint32(len(b)) |
| if int(n) != len(b) { |
| e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b))) |
| return |
| } |
| binary.BigEndian.PutUint32(e.header[:4], n) |
| e.header[4] = name[0] |
| e.header[5] = name[1] |
| e.header[6] = name[2] |
| e.header[7] = name[3] |
| crc := crc32.NewIEEE() |
| crc.Write(e.header[4:8]) |
| crc.Write(b) |
| binary.BigEndian.PutUint32(e.footer[:4], crc.Sum32()) |
| |
| _, e.err = e.w.Write(e.header[:8]) |
| if e.err != nil { |
| return |
| } |
| _, e.err = e.w.Write(b) |
| if e.err != nil { |
| return |
| } |
| _, e.err = e.w.Write(e.footer[:4]) |
| } |
| |
| func (e *encoder) writeIHDR() { |
| b := e.m.Bounds() |
| binary.BigEndian.PutUint32(e.tmp[0:4], uint32(b.Dx())) |
| binary.BigEndian.PutUint32(e.tmp[4:8], uint32(b.Dy())) |
| // Set bit depth and color type. |
| switch e.cb { |
| case cbG8: |
| e.tmp[8] = 8 |
| e.tmp[9] = ctGrayscale |
| case cbTC8: |
| e.tmp[8] = 8 |
| e.tmp[9] = ctTrueColor |
| case cbP8: |
| e.tmp[8] = 8 |
| e.tmp[9] = ctPaletted |
| case cbTCA8: |
| e.tmp[8] = 8 |
| e.tmp[9] = ctTrueColorAlpha |
| case cbG16: |
| e.tmp[8] = 16 |
| e.tmp[9] = ctGrayscale |
| case cbTC16: |
| e.tmp[8] = 16 |
| e.tmp[9] = ctTrueColor |
| case cbTCA16: |
| e.tmp[8] = 16 |
| e.tmp[9] = ctTrueColorAlpha |
| } |
| e.tmp[10] = 0 // default compression method |
| e.tmp[11] = 0 // default filter method |
| e.tmp[12] = 0 // non-interlaced |
| e.writeChunk(e.tmp[:13], "IHDR") |
| } |
| |
| func (e *encoder) writePLTEAndTRNS(p color.Palette) { |
| if len(p) < 1 || len(p) > 256 { |
| e.err = FormatError("bad palette length: " + strconv.Itoa(len(p))) |
| return |
| } |
| last := -1 |
| for i, c := range p { |
| c1 := color.NRGBAModel.Convert(c).(color.NRGBA) |
| e.tmp[3*i+0] = c1.R |
| e.tmp[3*i+1] = c1.G |
| e.tmp[3*i+2] = c1.B |
| if c1.A != 0xff { |
| last = i |
| } |
| e.tmp[3*256+i] = c1.A |
| } |
| e.writeChunk(e.tmp[:3*len(p)], "PLTE") |
| if last != -1 { |
| e.writeChunk(e.tmp[3*256:3*256+1+last], "tRNS") |
| } |
| } |
| |
| // An encoder is an io.Writer that satisfies writes by writing PNG IDAT chunks, |
| // including an 8-byte header and 4-byte CRC checksum per Write call. Such calls |
| // should be relatively infrequent, since writeIDATs uses a bufio.Writer. |
| // |
| // This method should only be called from writeIDATs (via writeImage). |
| // No other code should treat an encoder as an io.Writer. |
| func (e *encoder) Write(b []byte) (int, error) { |
| e.writeChunk(b, "IDAT") |
| if e.err != nil { |
| return 0, e.err |
| } |
| return len(b), nil |
| } |
| |
| // Chooses the filter to use for encoding the current row, and applies it. |
| // The return value is the index of the filter and also of the row in cr that has had it applied. |
| func filter(cr *[nFilter][]byte, pr []byte, bpp int) int { |
| // We try all five filter types, and pick the one that minimizes the sum of absolute differences. |
| // This is the same heuristic that libpng uses, although the filters are attempted in order of |
| // estimated most likely to be minimal (ftUp, ftPaeth, ftNone, ftSub, ftAverage), rather than |
| // in their enumeration order (ftNone, ftSub, ftUp, ftAverage, ftPaeth). |
| cdat0 := cr[0][1:] |
| cdat1 := cr[1][1:] |
| cdat2 := cr[2][1:] |
| cdat3 := cr[3][1:] |
| cdat4 := cr[4][1:] |
| pdat := pr[1:] |
| n := len(cdat0) |
| |
| // The up filter. |
| sum := 0 |
| for i := 0; i < n; i++ { |
| cdat2[i] = cdat0[i] - pdat[i] |
| sum += abs8(cdat2[i]) |
| } |
| best := sum |
| filter := ftUp |
| |
| // The Paeth filter. |
| sum = 0 |
| for i := 0; i < bpp; i++ { |
| cdat4[i] = cdat0[i] - pdat[i] |
| sum += abs8(cdat4[i]) |
| } |
| for i := bpp; i < n; i++ { |
| cdat4[i] = cdat0[i] - paeth(cdat0[i-bpp], pdat[i], pdat[i-bpp]) |
| sum += abs8(cdat4[i]) |
| if sum >= best { |
| break |
| } |
| } |
| if sum < best { |
| best = sum |
| filter = ftPaeth |
| } |
| |
| // The none filter. |
| sum = 0 |
| for i := 0; i < n; i++ { |
| sum += abs8(cdat0[i]) |
| if sum >= best { |
| break |
| } |
| } |
| if sum < best { |
| best = sum |
| filter = ftNone |
| } |
| |
| // The sub filter. |
| sum = 0 |
| for i := 0; i < bpp; i++ { |
| cdat1[i] = cdat0[i] |
| sum += abs8(cdat1[i]) |
| } |
| for i := bpp; i < n; i++ { |
| cdat1[i] = cdat0[i] - cdat0[i-bpp] |
| sum += abs8(cdat1[i]) |
| if sum >= best { |
| break |
| } |
| } |
| if sum < best { |
| best = sum |
| filter = ftSub |
| } |
| |
| // The average filter. |
| sum = 0 |
| for i := 0; i < bpp; i++ { |
| cdat3[i] = cdat0[i] - pdat[i]/2 |
| sum += abs8(cdat3[i]) |
| } |
| for i := bpp; i < n; i++ { |
| cdat3[i] = cdat0[i] - uint8((int(cdat0[i-bpp])+int(pdat[i]))/2) |
| sum += abs8(cdat3[i]) |
| if sum >= best { |
| break |
| } |
| } |
| if sum < best { |
| best = sum |
| filter = ftAverage |
| } |
| |
| return filter |
| } |
| |
| func zeroMemory(v []uint8) { |
| for i := range v { |
| v[i] = 0 |
| } |
| } |
| |
| func (e *encoder) writeImage(w io.Writer, m image.Image, cb int, level int) error { |
| if e.zw == nil || e.zwLevel != level { |
| zw, err := zlib.NewWriterLevel(w, level) |
| if err != nil { |
| return err |
| } |
| e.zw = zw |
| e.zwLevel = level |
| } else { |
| e.zw.Reset(w) |
| } |
| defer e.zw.Close() |
| |
| bpp := 0 // Bytes per pixel. |
| |
| switch cb { |
| case cbG8: |
| bpp = 1 |
| case cbTC8: |
| bpp = 3 |
| case cbP8: |
| bpp = 1 |
| case cbTCA8: |
| bpp = 4 |
| case cbTC16: |
| bpp = 6 |
| case cbTCA16: |
| bpp = 8 |
| case cbG16: |
| bpp = 2 |
| } |
| // cr[*] and pr are the bytes for the current and previous row. |
| // cr[0] is unfiltered (or equivalently, filtered with the ftNone filter). |
| // cr[ft], for non-zero filter types ft, are buffers for transforming cr[0] under the |
| // other PNG filter types. These buffers are allocated once and re-used for each row. |
| // The +1 is for the per-row filter type, which is at cr[*][0]. |
| b := m.Bounds() |
| sz := 1 + bpp*b.Dx() |
| for i := range e.cr { |
| if cap(e.cr[i]) < sz { |
| e.cr[i] = make([]uint8, sz) |
| } else { |
| e.cr[i] = e.cr[i][:sz] |
| } |
| e.cr[i][0] = uint8(i) |
| } |
| cr := e.cr |
| if cap(e.pr) < sz { |
| e.pr = make([]uint8, sz) |
| } else { |
| e.pr = e.pr[:sz] |
| zeroMemory(e.pr) |
| } |
| pr := e.pr |
| |
| gray, _ := m.(*image.Gray) |
| rgba, _ := m.(*image.RGBA) |
| paletted, _ := m.(*image.Paletted) |
| nrgba, _ := m.(*image.NRGBA) |
| |
| for y := b.Min.Y; y < b.Max.Y; y++ { |
| // Convert from colors to bytes. |
| i := 1 |
| switch cb { |
| case cbG8: |
| if gray != nil { |
| offset := (y - b.Min.Y) * gray.Stride |
| copy(cr[0][1:], gray.Pix[offset:offset+b.Dx()]) |
| } else { |
| for x := b.Min.X; x < b.Max.X; x++ { |
| c := color.GrayModel.Convert(m.At(x, y)).(color.Gray) |
| cr[0][i] = c.Y |
| i++ |
| } |
| } |
| case cbTC8: |
| // We have previously verified that the alpha value is fully opaque. |
| cr0 := cr[0] |
| stride, pix := 0, []byte(nil) |
| if rgba != nil { |
| stride, pix = rgba.Stride, rgba.Pix |
| } else if nrgba != nil { |
| stride, pix = nrgba.Stride, nrgba.Pix |
| } |
| if stride != 0 { |
| j0 := (y - b.Min.Y) * stride |
| j1 := j0 + b.Dx()*4 |
| for j := j0; j < j1; j += 4 { |
| cr0[i+0] = pix[j+0] |
| cr0[i+1] = pix[j+1] |
| cr0[i+2] = pix[j+2] |
| i += 3 |
| } |
| } else { |
| for x := b.Min.X; x < b.Max.X; x++ { |
| r, g, b, _ := m.At(x, y).RGBA() |
| cr0[i+0] = uint8(r >> 8) |
| cr0[i+1] = uint8(g >> 8) |
| cr0[i+2] = uint8(b >> 8) |
| i += 3 |
| } |
| } |
| case cbP8: |
| if paletted != nil { |
| offset := (y - b.Min.Y) * paletted.Stride |
| copy(cr[0][1:], paletted.Pix[offset:offset+b.Dx()]) |
| } else { |
| pi := m.(image.PalettedImage) |
| for x := b.Min.X; x < b.Max.X; x++ { |
| cr[0][i] = pi.ColorIndexAt(x, y) |
| i += 1 |
| } |
| } |
| case cbTCA8: |
| if nrgba != nil { |
| offset := (y - b.Min.Y) * nrgba.Stride |
| copy(cr[0][1:], nrgba.Pix[offset:offset+b.Dx()*4]) |
| } else { |
| // Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied. |
| for x := b.Min.X; x < b.Max.X; x++ { |
| c := color.NRGBAModel.Convert(m.At(x, y)).(color.NRGBA) |
| cr[0][i+0] = c.R |
| cr[0][i+1] = c.G |
| cr[0][i+2] = c.B |
| cr[0][i+3] = c.A |
| i += 4 |
| } |
| } |
| case cbG16: |
| for x := b.Min.X; x < b.Max.X; x++ { |
| c := color.Gray16Model.Convert(m.At(x, y)).(color.Gray16) |
| cr[0][i+0] = uint8(c.Y >> 8) |
| cr[0][i+1] = uint8(c.Y) |
| i += 2 |
| } |
| case cbTC16: |
| // We have previously verified that the alpha value is fully opaque. |
| for x := b.Min.X; x < b.Max.X; x++ { |
| r, g, b, _ := m.At(x, y).RGBA() |
| cr[0][i+0] = uint8(r >> 8) |
| cr[0][i+1] = uint8(r) |
| cr[0][i+2] = uint8(g >> 8) |
| cr[0][i+3] = uint8(g) |
| cr[0][i+4] = uint8(b >> 8) |
| cr[0][i+5] = uint8(b) |
| i += 6 |
| } |
| case cbTCA16: |
| // Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied. |
| for x := b.Min.X; x < b.Max.X; x++ { |
| c := color.NRGBA64Model.Convert(m.At(x, y)).(color.NRGBA64) |
| cr[0][i+0] = uint8(c.R >> 8) |
| cr[0][i+1] = uint8(c.R) |
| cr[0][i+2] = uint8(c.G >> 8) |
| cr[0][i+3] = uint8(c.G) |
| cr[0][i+4] = uint8(c.B >> 8) |
| cr[0][i+5] = uint8(c.B) |
| cr[0][i+6] = uint8(c.A >> 8) |
| cr[0][i+7] = uint8(c.A) |
| i += 8 |
| } |
| } |
| |
| // Apply the filter. |
| // Skip filter for NoCompression and paletted images (cbP8) as |
| // "filters are rarely useful on palette images" and will result |
| // in larger files (see http://www.libpng.org/pub/png/book/chapter09.html). |
| f := ftNone |
| if level != zlib.NoCompression && cb != cbP8 { |
| f = filter(&cr, pr, bpp) |
| } |
| |
| // Write the compressed bytes. |
| if _, err := e.zw.Write(cr[f]); err != nil { |
| return err |
| } |
| |
| // The current row for y is the previous row for y+1. |
| pr, cr[0] = cr[0], pr |
| } |
| return nil |
| } |
| |
| // Write the actual image data to one or more IDAT chunks. |
| func (e *encoder) writeIDATs() { |
| if e.err != nil { |
| return |
| } |
| if e.bw == nil { |
| e.bw = bufio.NewWriterSize(e, 1<<15) |
| } else { |
| e.bw.Reset(e) |
| } |
| e.err = e.writeImage(e.bw, e.m, e.cb, levelToZlib(e.enc.CompressionLevel)) |
| if e.err != nil { |
| return |
| } |
| e.err = e.bw.Flush() |
| } |
| |
| // This function is required because we want the zero value of |
| // Encoder.CompressionLevel to map to zlib.DefaultCompression. |
| func levelToZlib(l CompressionLevel) int { |
| switch l { |
| case DefaultCompression: |
| return zlib.DefaultCompression |
| case NoCompression: |
| return zlib.NoCompression |
| case BestSpeed: |
| return zlib.BestSpeed |
| case BestCompression: |
| return zlib.BestCompression |
| default: |
| return zlib.DefaultCompression |
| } |
| } |
| |
| func (e *encoder) writeIEND() { e.writeChunk(nil, "IEND") } |
| |
| // Encode writes the Image m to w in PNG format. Any Image may be |
| // encoded, but images that are not image.NRGBA might be encoded lossily. |
| func Encode(w io.Writer, m image.Image) error { |
| var e Encoder |
| return e.Encode(w, m) |
| } |
| |
| // Encode writes the Image m to w in PNG format. |
| func (enc *Encoder) Encode(w io.Writer, m image.Image) error { |
| // Obviously, negative widths and heights are invalid. Furthermore, the PNG |
| // spec section 11.2.2 says that zero is invalid. Excessively large images are |
| // also rejected. |
| mw, mh := int64(m.Bounds().Dx()), int64(m.Bounds().Dy()) |
| if mw <= 0 || mh <= 0 || mw >= 1<<32 || mh >= 1<<32 { |
| return FormatError("invalid image size: " + strconv.FormatInt(mw, 10) + "x" + strconv.FormatInt(mh, 10)) |
| } |
| |
| var e *encoder |
| if enc.BufferPool != nil { |
| buffer := enc.BufferPool.Get() |
| e = (*encoder)(buffer) |
| |
| } |
| if e == nil { |
| e = &encoder{} |
| } |
| if enc.BufferPool != nil { |
| defer enc.BufferPool.Put((*EncoderBuffer)(e)) |
| } |
| |
| e.enc = enc |
| e.w = w |
| e.m = m |
| |
| var pal color.Palette |
| // cbP8 encoding needs PalettedImage's ColorIndexAt method. |
| if _, ok := m.(image.PalettedImage); ok { |
| pal, _ = m.ColorModel().(color.Palette) |
| } |
| if pal != nil { |
| e.cb = cbP8 |
| } else { |
| switch m.ColorModel() { |
| case color.GrayModel: |
| e.cb = cbG8 |
| case color.Gray16Model: |
| e.cb = cbG16 |
| case color.RGBAModel, color.NRGBAModel, color.AlphaModel: |
| if opaque(m) { |
| e.cb = cbTC8 |
| } else { |
| e.cb = cbTCA8 |
| } |
| default: |
| if opaque(m) { |
| e.cb = cbTC16 |
| } else { |
| e.cb = cbTCA16 |
| } |
| } |
| } |
| |
| _, e.err = io.WriteString(w, pngHeader) |
| e.writeIHDR() |
| if pal != nil { |
| e.writePLTEAndTRNS(pal) |
| } |
| e.writeIDATs() |
| e.writeIEND() |
| return e.err |
| } |
