code review 6866051: tiff: support for writing compressed images.

tiff/writer.go

 // Copyright 2012 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 tiff
 
 import (
+        "bytes"
+        "compress/zlib"
         "encoding/binary"
         "image"
         "io"
         "sort"
 )
 
 // The TIFF format allows to choose the order of the different elements freely.
 // The basic structure of a TIFF file written by this package is:
 //
 //   1. Header (8 bytes).
@@ skipping 154 matching lines @@
         // types of images and compressors. For example, it works well for
         // photos with Deflate compression.
         Predictor bool
 }
 
 // Encode writes the image m to w. opt determines the options used for
 // encoding, such as the compression type. If opt is nil, an uncompressed
 // image is written.
 func Encode(w io.Writer, m image.Image, opt *Options) error {
         predictor := false
-        compression := Uncompressed
+        compression := uint32(cNone)
         if opt != nil {
                 predictor = opt.Predictor
-                compression = opt.Compression
-        }
-        if compression != Uncompressed {
-                return UnsupportedError("compression type")
+                compression = opt.Compression.specValue()
         }
 
-        var extrasamples uint32
         _, err := io.WriteString(w, leHeader)
         if err != nil {
                 return err
         }
 
+        // Compressed data is written into a buffer first, so that we
+        // know the compressed size.
+        var buf bytes.Buffer
+        // dst holds the destination for the pixel data of the image --
+        // either w or a writer to buf.
+        var dst io.Writer
+        // imageLen is the length of the pixel data in bytes.
+        // The offset of the IFD is imageLen + 8 header bytes.
+        var imageLen int
         bounds := m.Bounds()
         width, height := bounds.Dx(), bounds.Dy()
-        // imageLen is the length of the image data in bytes.
-        imageLen := width * height * 4
-        ifdOffset := imageLen + 8 // 8 bytes for TIFF header.
-        err = binary.Write(w, enc, uint32(ifdOffset))
-        if err != nil {
-                return err
+
+        switch compression {
+        case cNone:
+                dst = w
+                // Write IFD offset before outputting pixel data.
+                imageLen = width * height * 4
+                err = binary.Write(w, enc, uint32(imageLen+8))
+                if err != nil {
+                        return err
+                }
+        case cDeflate:
+                dst = zlib.NewWriter(&buf)
         }
+
         var pr uint32 = prNone
-        extrasamples = 1 // Associated alpha (default).
+        var extrasamples uint32 = 1 // Associated alpha (default).
         if predictor {
                 pr = prHorizontal
-                err = writeImgData(w, m, predictor)
+                err = writeImgData(dst, m, predictor)
         } else {
                 switch img := m.(type) {
                 case *image.NRGBA:
                         extrasamples = 2 // Unassociated alpha.
                         off := img.PixOffset(img.Rect.Min.X, img.Rect.Min.Y)
-                        err = writePix(w, img.Pix[off:], img.Rect.Dy(), 4*img.Rect.Dx(), img.Stride)
+                        err = writePix(dst, img.Pix[off:], img.Rect.Dy(), 4*img.Rect.Dx(), img.Stride)
                 case *image.RGBA:
                         off := img.PixOffset(img.Rect.Min.X, img.Rect.Min.Y)
-                        err = writePix(w, img.Pix[off:], img.Rect.Dy(), 4*img.Rect.Dx(), img.Stride)
+                        err = writePix(dst, img.Pix[off:], img.Rect.Dy(), 4*img.Rect.Dx(), img.Stride)
                 default:
-                        err = writeImgData(w, m, predictor)
+                        err = writeImgData(dst, m, predictor)
                 }
         }
         if err != nil {
                 return err
         }
 
-        return writeIFD(w, ifdOffset, []ifdEntry{
+        if compression != cNone {
+                if err = dst.(io.Closer).Close(); err != nil {
+                        return err
+                }
+                imageLen = buf.Len()
+                if err = binary.Write(w, enc, uint32(imageLen+8)); err != nil {
+                        return err
+                }
+                if _, err = buf.WriteTo(w); err != nil {
+                        return err
+                }
+        }
+
+        return writeIFD(w, imageLen+8, []ifdEntry{
                 {tImageWidth, dtShort, []uint32{uint32(width)}},
                 {tImageLength, dtShort, []uint32{uint32(height)}},
                 {tBitsPerSample, dtShort, []uint32{8, 8, 8, 8}},
-                {tCompression, dtShort, []uint32{cNone}},
+                {tCompression, dtShort, []uint32{compression}},
                 {tPhotometricInterpretation, dtShort, []uint32{pRGB}},
                 {tStripOffsets, dtLong, []uint32{8}},
                 {tSamplesPerPixel, dtShort, []uint32{4}},
                 {tRowsPerStrip, dtShort, []uint32{uint32(height)}},
                 {tStripByteCounts, dtLong, []uint32{uint32(imageLen)}},
                 // There is currently no support for storing the image
                 // resolution, so give a bogus value of 72x72 dpi.
                 {tXResolution, dtRational, []uint32{72, 1}},
                 {tYResolution, dtRational, []uint32{72, 1}},
                 {tResolutionUnit, dtShort, []uint32{resPerInch}},
                 {tPredictor, dtShort, []uint32{pr}},
                 {tExtraSamples, dtShort, []uint32{extrasamples}},
         })
 }