| // Copyright 2011 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 implements a TIFF image decoder and encoder. |
| // |
| // The TIFF specification is at http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf |
| package tiff // import "golang.org/x/image/tiff" |
| |
| import ( |
| "bytes" |
| "compress/zlib" |
| "encoding/binary" |
| "fmt" |
| "image" |
| "image/color" |
| "io" |
| "math" |
| |
| "golang.org/x/image/ccitt" |
| "golang.org/x/image/tiff/lzw" |
| ) |
| |
| // A FormatError reports that the input is not a valid TIFF image. |
| type FormatError string |
| |
| func (e FormatError) Error() string { |
| return "tiff: invalid format: " + string(e) |
| } |
| |
| // An UnsupportedError reports that the input uses a valid but |
| // unimplemented feature. |
| type UnsupportedError string |
| |
| func (e UnsupportedError) Error() string { |
| return "tiff: unsupported feature: " + string(e) |
| } |
| |
| var ( |
| errNoPixels = FormatError("not enough pixel data") |
| errInvalidColorIndex = FormatError("invalid color index") |
| ) |
| |
| const maxChunkSize = 10 << 20 // 10M |
| |
| // safeReadAt is a verbatim copy of internal/saferio.ReadDataAt from the |
| // standard library, which is used to read data from a reader using a length |
| // provided by untrusted data, without allocating the entire slice ahead of time |
| // if it is large (>maxChunkSize). This allows us to avoid allocating giant |
| // slices before learning that we can't actually read that much data from the |
| // reader. |
| func safeReadAt(r io.ReaderAt, n uint64, off int64) ([]byte, error) { |
| if int64(n) < 0 || n != uint64(int(n)) { |
| // n is too large to fit in int, so we can't allocate |
| // a buffer large enough. Treat this as a read failure. |
| return nil, io.ErrUnexpectedEOF |
| } |
| |
| if n < maxChunkSize { |
| buf := make([]byte, n) |
| _, err := r.ReadAt(buf, off) |
| if err != nil { |
| // io.SectionReader can return EOF for n == 0, |
| // but for our purposes that is a success. |
| if err != io.EOF || n > 0 { |
| return nil, err |
| } |
| } |
| return buf, nil |
| } |
| |
| var buf []byte |
| buf1 := make([]byte, maxChunkSize) |
| for n > 0 { |
| next := n |
| if next > maxChunkSize { |
| next = maxChunkSize |
| } |
| _, err := r.ReadAt(buf1[:next], off) |
| if err != nil { |
| return nil, err |
| } |
| buf = append(buf, buf1[:next]...) |
| n -= next |
| off += int64(next) |
| } |
| return buf, nil |
| } |
| |
| type decoder struct { |
| r io.ReaderAt |
| byteOrder binary.ByteOrder |
| config image.Config |
| mode imageMode |
| bpp uint |
| features map[int][]uint |
| palette []color.Color |
| |
| buf []byte |
| off int // Current offset in buf. |
| v uint32 // Buffer value for reading with arbitrary bit depths. |
| nbits uint // Remaining number of bits in v. |
| } |
| |
| // firstVal returns the first uint of the features entry with the given tag, |
| // or 0 if the tag does not exist. |
| func (d *decoder) firstVal(tag int) uint { |
| f := d.features[tag] |
| if len(f) == 0 { |
| return 0 |
| } |
| return f[0] |
| } |
| |
| // ifdUint decodes the IFD entry in p, which must be of the Byte, Short |
| // or Long type, and returns the decoded uint values. |
| func (d *decoder) ifdUint(p []byte) (u []uint, err error) { |
| var raw []byte |
| if len(p) < ifdLen { |
| return nil, FormatError("bad IFD entry") |
| } |
| |
| datatype := d.byteOrder.Uint16(p[2:4]) |
| if dt := int(datatype); dt <= 0 || dt >= len(lengths) { |
| return nil, UnsupportedError("IFD entry datatype") |
| } |
| |
| count := d.byteOrder.Uint32(p[4:8]) |
| if count > math.MaxInt32/lengths[datatype] { |
| return nil, FormatError("IFD data too large") |
| } |
| if datalen := lengths[datatype] * count; datalen > 4 { |
| // The IFD contains a pointer to the real value. |
| raw, err = safeReadAt(d.r, uint64(datalen), int64(d.byteOrder.Uint32(p[8:12]))) |
| } else { |
| raw = p[8 : 8+datalen] |
| } |
| if err != nil { |
| return nil, err |
| } |
| |
| u = make([]uint, count) |
| switch datatype { |
| case dtByte: |
| for i := uint32(0); i < count; i++ { |
| u[i] = uint(raw[i]) |
| } |
| case dtShort: |
| for i := uint32(0); i < count; i++ { |
| u[i] = uint(d.byteOrder.Uint16(raw[2*i : 2*(i+1)])) |
| } |
| case dtLong: |
| for i := uint32(0); i < count; i++ { |
| u[i] = uint(d.byteOrder.Uint32(raw[4*i : 4*(i+1)])) |
| } |
| default: |
| return nil, UnsupportedError("data type") |
| } |
| return u, nil |
| } |
| |
| // parseIFD decides whether the IFD entry in p is "interesting" and |
| // stows away the data in the decoder. It returns the tag number of the |
| // entry and an error, if any. |
| func (d *decoder) parseIFD(p []byte) (int, error) { |
| tag := d.byteOrder.Uint16(p[0:2]) |
| switch tag { |
| case tBitsPerSample, |
| tExtraSamples, |
| tPhotometricInterpretation, |
| tCompression, |
| tPredictor, |
| tStripOffsets, |
| tStripByteCounts, |
| tRowsPerStrip, |
| tTileWidth, |
| tTileLength, |
| tTileOffsets, |
| tTileByteCounts, |
| tImageLength, |
| tImageWidth, |
| tFillOrder, |
| tT4Options, |
| tT6Options: |
| val, err := d.ifdUint(p) |
| if err != nil { |
| return 0, err |
| } |
| d.features[int(tag)] = val |
| case tColorMap: |
| val, err := d.ifdUint(p) |
| if err != nil { |
| return 0, err |
| } |
| numcolors := len(val) / 3 |
| if len(val)%3 != 0 || numcolors <= 0 || numcolors > 256 { |
| return 0, FormatError("bad ColorMap length") |
| } |
| d.palette = make([]color.Color, numcolors) |
| for i := 0; i < numcolors; i++ { |
| d.palette[i] = color.RGBA64{ |
| uint16(val[i]), |
| uint16(val[i+numcolors]), |
| uint16(val[i+2*numcolors]), |
| 0xffff, |
| } |
| } |
| case tSampleFormat: |
| // Page 27 of the spec: If the SampleFormat is present and |
| // the value is not 1 [= unsigned integer data], a Baseline |
| // TIFF reader that cannot handle the SampleFormat value |
| // must terminate the import process gracefully. |
| val, err := d.ifdUint(p) |
| if err != nil { |
| return 0, err |
| } |
| for _, v := range val { |
| if v != 1 { |
| return 0, UnsupportedError("sample format") |
| } |
| } |
| } |
| return int(tag), nil |
| } |
| |
| // readBits reads n bits from the internal buffer starting at the current offset. |
| func (d *decoder) readBits(n uint) (v uint32, ok bool) { |
| for d.nbits < n { |
| d.v <<= 8 |
| if d.off >= len(d.buf) { |
| return 0, false |
| } |
| d.v |= uint32(d.buf[d.off]) |
| d.off++ |
| d.nbits += 8 |
| } |
| d.nbits -= n |
| rv := d.v >> d.nbits |
| d.v &^= rv << d.nbits |
| return rv, true |
| } |
| |
| // flushBits discards the unread bits in the buffer used by readBits. |
| // It is used at the end of a line. |
| func (d *decoder) flushBits() { |
| d.v = 0 |
| d.nbits = 0 |
| } |
| |
| // minInt returns the smaller of x or y. |
| func minInt(a, b int) int { |
| if a <= b { |
| return a |
| } |
| return b |
| } |
| |
| // decode decodes the raw data of an image. |
| // It reads from d.buf and writes the strip or tile into dst. |
| func (d *decoder) decode(dst image.Image, xmin, ymin, xmax, ymax int) error { |
| d.off = 0 |
| |
| // Apply horizontal predictor if necessary. |
| // In this case, p contains the color difference to the preceding pixel. |
| // See page 64-65 of the spec. |
| if d.firstVal(tPredictor) == prHorizontal { |
| switch d.bpp { |
| case 16: |
| var off int |
| n := 2 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel |
| for y := ymin; y < ymax; y++ { |
| off += n |
| for x := 0; x < (xmax-xmin-1)*n; x += 2 { |
| if off+2 > len(d.buf) { |
| return errNoPixels |
| } |
| v0 := d.byteOrder.Uint16(d.buf[off-n : off-n+2]) |
| v1 := d.byteOrder.Uint16(d.buf[off : off+2]) |
| d.byteOrder.PutUint16(d.buf[off:off+2], v1+v0) |
| off += 2 |
| } |
| } |
| case 8: |
| var off int |
| n := 1 * len(d.features[tBitsPerSample]) // bytes per sample times samples per pixel |
| for y := ymin; y < ymax; y++ { |
| off += n |
| for x := 0; x < (xmax-xmin-1)*n; x++ { |
| if off >= len(d.buf) { |
| return errNoPixels |
| } |
| d.buf[off] += d.buf[off-n] |
| off++ |
| } |
| } |
| case 1: |
| return UnsupportedError("horizontal predictor with 1 BitsPerSample") |
| } |
| } |
| |
| rMaxX := minInt(xmax, dst.Bounds().Max.X) |
| rMaxY := minInt(ymax, dst.Bounds().Max.Y) |
| switch d.mode { |
| case mGray, mGrayInvert: |
| if d.bpp == 16 { |
| img := dst.(*image.Gray16) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| if d.off+2 > len(d.buf) { |
| return errNoPixels |
| } |
| v := d.byteOrder.Uint16(d.buf[d.off : d.off+2]) |
| d.off += 2 |
| if d.mode == mGrayInvert { |
| v = 0xffff - v |
| } |
| img.SetGray16(x, y, color.Gray16{v}) |
| } |
| if rMaxX == img.Bounds().Max.X { |
| d.off += 2 * (xmax - img.Bounds().Max.X) |
| } |
| } |
| } else { |
| img := dst.(*image.Gray) |
| max := uint32((1 << d.bpp) - 1) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| v, ok := d.readBits(d.bpp) |
| if !ok { |
| return errNoPixels |
| } |
| v = v * 0xff / max |
| if d.mode == mGrayInvert { |
| v = 0xff - v |
| } |
| img.SetGray(x, y, color.Gray{uint8(v)}) |
| } |
| d.flushBits() |
| } |
| } |
| case mPaletted: |
| img := dst.(*image.Paletted) |
| pLen := len(d.palette) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| v, ok := d.readBits(d.bpp) |
| if !ok { |
| return errNoPixels |
| } |
| idx := uint8(v) |
| if int(idx) >= pLen { |
| return errInvalidColorIndex |
| } |
| img.SetColorIndex(x, y, idx) |
| } |
| d.flushBits() |
| } |
| case mRGB: |
| if d.bpp == 16 { |
| img := dst.(*image.RGBA64) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| if d.off+6 > len(d.buf) { |
| return errNoPixels |
| } |
| r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) |
| g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) |
| b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) |
| d.off += 6 |
| img.SetRGBA64(x, y, color.RGBA64{r, g, b, 0xffff}) |
| } |
| } |
| } else { |
| img := dst.(*image.RGBA) |
| for y := ymin; y < rMaxY; y++ { |
| min := img.PixOffset(xmin, y) |
| max := img.PixOffset(rMaxX, y) |
| off := (y - ymin) * (xmax - xmin) * 3 |
| for i := min; i < max; i += 4 { |
| if off+3 > len(d.buf) { |
| return errNoPixels |
| } |
| img.Pix[i+0] = d.buf[off+0] |
| img.Pix[i+1] = d.buf[off+1] |
| img.Pix[i+2] = d.buf[off+2] |
| img.Pix[i+3] = 0xff |
| off += 3 |
| } |
| } |
| } |
| case mNRGBA: |
| if d.bpp == 16 { |
| img := dst.(*image.NRGBA64) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| if d.off+8 > len(d.buf) { |
| return errNoPixels |
| } |
| r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) |
| g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) |
| b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) |
| a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8]) |
| d.off += 8 |
| img.SetNRGBA64(x, y, color.NRGBA64{r, g, b, a}) |
| } |
| } |
| } else { |
| img := dst.(*image.NRGBA) |
| for y := ymin; y < rMaxY; y++ { |
| min := img.PixOffset(xmin, y) |
| max := img.PixOffset(rMaxX, y) |
| i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4 |
| if i1 > len(d.buf) { |
| return errNoPixels |
| } |
| copy(img.Pix[min:max], d.buf[i0:i1]) |
| } |
| } |
| case mRGBA: |
| if d.bpp == 16 { |
| img := dst.(*image.RGBA64) |
| for y := ymin; y < rMaxY; y++ { |
| for x := xmin; x < rMaxX; x++ { |
| if d.off+8 > len(d.buf) { |
| return errNoPixels |
| } |
| r := d.byteOrder.Uint16(d.buf[d.off+0 : d.off+2]) |
| g := d.byteOrder.Uint16(d.buf[d.off+2 : d.off+4]) |
| b := d.byteOrder.Uint16(d.buf[d.off+4 : d.off+6]) |
| a := d.byteOrder.Uint16(d.buf[d.off+6 : d.off+8]) |
| d.off += 8 |
| img.SetRGBA64(x, y, color.RGBA64{r, g, b, a}) |
| } |
| } |
| } else { |
| img := dst.(*image.RGBA) |
| for y := ymin; y < rMaxY; y++ { |
| min := img.PixOffset(xmin, y) |
| max := img.PixOffset(rMaxX, y) |
| i0, i1 := (y-ymin)*(xmax-xmin)*4, (y-ymin+1)*(xmax-xmin)*4 |
| if i1 > len(d.buf) { |
| return errNoPixels |
| } |
| copy(img.Pix[min:max], d.buf[i0:i1]) |
| } |
| } |
| } |
| |
| return nil |
| } |
| |
| func newDecoder(r io.Reader) (*decoder, error) { |
| d := &decoder{ |
| r: newReaderAt(r), |
| features: make(map[int][]uint), |
| } |
| |
| p := make([]byte, 8) |
| if _, err := d.r.ReadAt(p, 0); err != nil { |
| if err == io.EOF { |
| err = io.ErrUnexpectedEOF |
| } |
| return nil, err |
| } |
| switch string(p[0:4]) { |
| case leHeader: |
| d.byteOrder = binary.LittleEndian |
| case beHeader: |
| d.byteOrder = binary.BigEndian |
| default: |
| return nil, FormatError("malformed header") |
| } |
| |
| ifdOffset := int64(d.byteOrder.Uint32(p[4:8])) |
| |
| // The first two bytes contain the number of entries (12 bytes each). |
| if _, err := d.r.ReadAt(p[0:2], ifdOffset); err != nil { |
| return nil, err |
| } |
| numItems := int(d.byteOrder.Uint16(p[0:2])) |
| |
| // All IFD entries are read in one chunk. |
| var err error |
| p, err = safeReadAt(d.r, uint64(ifdLen*numItems), ifdOffset+2) |
| if err != nil { |
| return nil, err |
| } |
| |
| prevTag := -1 |
| for i := 0; i < len(p); i += ifdLen { |
| tag, err := d.parseIFD(p[i : i+ifdLen]) |
| if err != nil { |
| return nil, err |
| } |
| if tag <= prevTag { |
| return nil, FormatError("tags are not sorted in ascending order") |
| } |
| prevTag = tag |
| } |
| |
| d.config.Width = int(d.firstVal(tImageWidth)) |
| d.config.Height = int(d.firstVal(tImageLength)) |
| |
| if _, ok := d.features[tBitsPerSample]; !ok { |
| // Default is 1 per specification. |
| d.features[tBitsPerSample] = []uint{1} |
| } |
| d.bpp = d.firstVal(tBitsPerSample) |
| switch d.bpp { |
| case 0: |
| return nil, FormatError("BitsPerSample must not be 0") |
| case 1, 8, 16: |
| // Nothing to do, these are accepted by this implementation. |
| default: |
| return nil, UnsupportedError(fmt.Sprintf("BitsPerSample of %v", d.bpp)) |
| } |
| |
| // Determine the image mode. |
| switch d.firstVal(tPhotometricInterpretation) { |
| case pRGB: |
| if d.bpp == 16 { |
| for _, b := range d.features[tBitsPerSample] { |
| if b != 16 { |
| return nil, FormatError("wrong number of samples for 16bit RGB") |
| } |
| } |
| } else { |
| for _, b := range d.features[tBitsPerSample] { |
| if b != 8 { |
| return nil, FormatError("wrong number of samples for 8bit RGB") |
| } |
| } |
| } |
| // RGB images normally have 3 samples per pixel. |
| // If there are more, ExtraSamples (p. 31-32 of the spec) |
| // gives their meaning (usually an alpha channel). |
| // |
| // This implementation does not support extra samples |
| // of an unspecified type. |
| switch len(d.features[tBitsPerSample]) { |
| case 3: |
| d.mode = mRGB |
| if d.bpp == 16 { |
| d.config.ColorModel = color.RGBA64Model |
| } else { |
| d.config.ColorModel = color.RGBAModel |
| } |
| case 4: |
| switch d.firstVal(tExtraSamples) { |
| case 1: |
| d.mode = mRGBA |
| if d.bpp == 16 { |
| d.config.ColorModel = color.RGBA64Model |
| } else { |
| d.config.ColorModel = color.RGBAModel |
| } |
| case 2: |
| d.mode = mNRGBA |
| if d.bpp == 16 { |
| d.config.ColorModel = color.NRGBA64Model |
| } else { |
| d.config.ColorModel = color.NRGBAModel |
| } |
| default: |
| return nil, FormatError("wrong number of samples for RGB") |
| } |
| default: |
| return nil, FormatError("wrong number of samples for RGB") |
| } |
| case pPaletted: |
| d.mode = mPaletted |
| d.config.ColorModel = color.Palette(d.palette) |
| case pWhiteIsZero: |
| d.mode = mGrayInvert |
| if d.bpp == 16 { |
| d.config.ColorModel = color.Gray16Model |
| } else { |
| d.config.ColorModel = color.GrayModel |
| } |
| case pBlackIsZero: |
| d.mode = mGray |
| if d.bpp == 16 { |
| d.config.ColorModel = color.Gray16Model |
| } else { |
| d.config.ColorModel = color.GrayModel |
| } |
| default: |
| return nil, UnsupportedError("color model") |
| } |
| if d.firstVal(tPhotometricInterpretation) != pRGB { |
| if len(d.features[tBitsPerSample]) != 1 { |
| return nil, UnsupportedError("extra samples") |
| } |
| } |
| |
| return d, nil |
| } |
| |
| // DecodeConfig returns the color model and dimensions of a TIFF image without |
| // decoding the entire image. |
| func DecodeConfig(r io.Reader) (image.Config, error) { |
| d, err := newDecoder(r) |
| if err != nil { |
| return image.Config{}, err |
| } |
| return d.config, nil |
| } |
| |
| func ccittFillOrder(tiffFillOrder uint) ccitt.Order { |
| if tiffFillOrder == 2 { |
| return ccitt.LSB |
| } |
| return ccitt.MSB |
| } |
| |
| // Decode reads a TIFF image from r and returns it as an image.Image. |
| // The type of Image returned depends on the contents of the TIFF. |
| func Decode(r io.Reader) (img image.Image, err error) { |
| d, err := newDecoder(r) |
| if err != nil { |
| return |
| } |
| |
| blockPadding := false |
| blockWidth := d.config.Width |
| blockHeight := d.config.Height |
| blocksAcross := 1 |
| blocksDown := 1 |
| |
| if d.config.Width == 0 { |
| blocksAcross = 0 |
| } |
| if d.config.Height == 0 { |
| blocksDown = 0 |
| } |
| |
| var blockOffsets, blockCounts []uint |
| |
| if int(d.firstVal(tTileWidth)) != 0 { |
| blockPadding = true |
| |
| blockWidth = int(d.firstVal(tTileWidth)) |
| blockHeight = int(d.firstVal(tTileLength)) |
| |
| // The specification says that tile widths and lengths must be a multiple of 16. |
| // We currently permit invalid sizes, but reject anything too small to limit the |
| // amount of work a malicious input can force us to perform. |
| if blockWidth < 8 || blockHeight < 8 { |
| return nil, FormatError("tile size is too small") |
| } |
| |
| if blockWidth != 0 { |
| blocksAcross = (d.config.Width + blockWidth - 1) / blockWidth |
| } |
| if blockHeight != 0 { |
| blocksDown = (d.config.Height + blockHeight - 1) / blockHeight |
| } |
| |
| blockCounts = d.features[tTileByteCounts] |
| blockOffsets = d.features[tTileOffsets] |
| |
| } else { |
| if int(d.firstVal(tRowsPerStrip)) != 0 { |
| blockHeight = int(d.firstVal(tRowsPerStrip)) |
| } |
| |
| if blockHeight != 0 { |
| blocksDown = (d.config.Height + blockHeight - 1) / blockHeight |
| } |
| |
| blockOffsets = d.features[tStripOffsets] |
| blockCounts = d.features[tStripByteCounts] |
| } |
| |
| // Check if we have the right number of strips/tiles, offsets and counts. |
| if n := blocksAcross * blocksDown; len(blockOffsets) < n || len(blockCounts) < n { |
| return nil, FormatError("inconsistent header") |
| } |
| |
| imgRect := image.Rect(0, 0, d.config.Width, d.config.Height) |
| switch d.mode { |
| case mGray, mGrayInvert: |
| if d.bpp == 16 { |
| img = image.NewGray16(imgRect) |
| } else { |
| img = image.NewGray(imgRect) |
| } |
| case mPaletted: |
| img = image.NewPaletted(imgRect, d.palette) |
| case mNRGBA: |
| if d.bpp == 16 { |
| img = image.NewNRGBA64(imgRect) |
| } else { |
| img = image.NewNRGBA(imgRect) |
| } |
| case mRGB, mRGBA: |
| if d.bpp == 16 { |
| img = image.NewRGBA64(imgRect) |
| } else { |
| img = image.NewRGBA(imgRect) |
| } |
| } |
| |
| if blocksAcross == 0 || blocksDown == 0 { |
| return |
| } |
| // Maximum data per pixel is 8 bytes (RGBA64). |
| blockMaxDataSize := int64(blockWidth) * int64(blockHeight) * 8 |
| for i := 0; i < blocksAcross; i++ { |
| blkW := blockWidth |
| if !blockPadding && i == blocksAcross-1 && d.config.Width%blockWidth != 0 { |
| blkW = d.config.Width % blockWidth |
| } |
| for j := 0; j < blocksDown; j++ { |
| blkH := blockHeight |
| if !blockPadding && j == blocksDown-1 && d.config.Height%blockHeight != 0 { |
| blkH = d.config.Height % blockHeight |
| } |
| offset := int64(blockOffsets[j*blocksAcross+i]) |
| n := int64(blockCounts[j*blocksAcross+i]) |
| switch d.firstVal(tCompression) { |
| |
| // According to the spec, Compression does not have a default value, |
| // but some tools interpret a missing Compression value as none so we do |
| // the same. |
| case cNone, 0: |
| if b, ok := d.r.(*buffer); ok { |
| d.buf, err = b.Slice(int(offset), int(n)) |
| } else { |
| d.buf, err = safeReadAt(d.r, uint64(n), offset) |
| } |
| case cG3: |
| inv := d.firstVal(tPhotometricInterpretation) == pWhiteIsZero |
| order := ccittFillOrder(d.firstVal(tFillOrder)) |
| r := ccitt.NewReader(io.NewSectionReader(d.r, offset, n), order, ccitt.Group3, blkW, blkH, &ccitt.Options{Invert: inv, Align: false}) |
| d.buf, err = readBuf(r, d.buf, blockMaxDataSize) |
| case cG4: |
| inv := d.firstVal(tPhotometricInterpretation) == pWhiteIsZero |
| order := ccittFillOrder(d.firstVal(tFillOrder)) |
| r := ccitt.NewReader(io.NewSectionReader(d.r, offset, n), order, ccitt.Group4, blkW, blkH, &ccitt.Options{Invert: inv, Align: false}) |
| d.buf, err = readBuf(r, d.buf, blockMaxDataSize) |
| case cLZW: |
| r := lzw.NewReader(io.NewSectionReader(d.r, offset, n), lzw.MSB, 8) |
| d.buf, err = readBuf(r, d.buf, blockMaxDataSize) |
| r.Close() |
| case cDeflate, cDeflateOld: |
| var r io.ReadCloser |
| r, err = zlib.NewReader(io.NewSectionReader(d.r, offset, n)) |
| if err != nil { |
| return nil, err |
| } |
| d.buf, err = readBuf(r, d.buf, blockMaxDataSize) |
| r.Close() |
| case cPackBits: |
| d.buf, err = unpackBits(io.NewSectionReader(d.r, offset, n)) |
| default: |
| err = UnsupportedError(fmt.Sprintf("compression value %d", d.firstVal(tCompression))) |
| } |
| if err != nil { |
| return nil, err |
| } |
| |
| xmin := i * blockWidth |
| ymin := j * blockHeight |
| xmax := xmin + blkW |
| ymax := ymin + blkH |
| err = d.decode(img, xmin, ymin, xmax, ymax) |
| if err != nil { |
| return nil, err |
| } |
| } |
| } |
| return |
| } |
| |
| func readBuf(r io.Reader, buf []byte, lim int64) ([]byte, error) { |
| b := bytes.NewBuffer(buf[:0]) |
| _, err := b.ReadFrom(io.LimitReader(r, lim)) |
| return b.Bytes(), err |
| } |
| |
| func init() { |
| image.RegisterFormat("tiff", leHeader, Decode, DecodeConfig) |
| image.RegisterFormat("tiff", beHeader, Decode, DecodeConfig) |
| } |
