writer.go

Documentation: image/jpeg

		 1  // Copyright 2011 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 jpeg
		 6  
		 7  import (
		 8  	"bufio"
		 9  	"errors"
		10  	"image"
		11  	"image/color"
		12  	"io"
		13  )
		14  
		15  // min returns the minimum of two integers.
		16  func min(x, y int) int {
		17  	if x < y {
		18  		return x
		19  	}
		20  	return y
		21  }
		22  
		23  // div returns a/b rounded to the nearest integer, instead of rounded to zero.
		24  func div(a, b int32) int32 {
		25  	if a >= 0 {
		26  		return (a + (b >> 1)) / b
		27  	}
		28  	return -((-a + (b >> 1)) / b)
		29  }
		30  
		31  // bitCount counts the number of bits needed to hold an integer.
		32  var bitCount = [256]byte{
		33  	0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
		34  	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
		35  	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		36  	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		37  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		38  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		39  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		40  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		41  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		42  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		43  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		44  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		45  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		46  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		47  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		48  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
		49  }
		50  
		51  type quantIndex int
		52  
		53  const (
		54  	quantIndexLuminance quantIndex = iota
		55  	quantIndexChrominance
		56  	nQuantIndex
		57  )
		58  
		59  // unscaledQuant are the unscaled quantization tables in zig-zag order. Each
		60  // encoder copies and scales the tables according to its quality parameter.
		61  // The values are derived from section K.1 after converting from natural to
		62  // zig-zag order.
		63  var unscaledQuant = [nQuantIndex][blockSize]byte{
		64  	// Luminance.
		65  	{
		66  		16, 11, 12, 14, 12, 10, 16, 14,
		67  		13, 14, 18, 17, 16, 19, 24, 40,
		68  		26, 24, 22, 22, 24, 49, 35, 37,
		69  		29, 40, 58, 51, 61, 60, 57, 51,
		70  		56, 55, 64, 72, 92, 78, 64, 68,
		71  		87, 69, 55, 56, 80, 109, 81, 87,
		72  		95, 98, 103, 104, 103, 62, 77, 113,
		73  		121, 112, 100, 120, 92, 101, 103, 99,
		74  	},
		75  	// Chrominance.
		76  	{
		77  		17, 18, 18, 24, 21, 24, 47, 26,
		78  		26, 47, 99, 66, 56, 66, 99, 99,
		79  		99, 99, 99, 99, 99, 99, 99, 99,
		80  		99, 99, 99, 99, 99, 99, 99, 99,
		81  		99, 99, 99, 99, 99, 99, 99, 99,
		82  		99, 99, 99, 99, 99, 99, 99, 99,
		83  		99, 99, 99, 99, 99, 99, 99, 99,
		84  		99, 99, 99, 99, 99, 99, 99, 99,
		85  	},
		86  }
		87  
		88  type huffIndex int
		89  
		90  const (
		91  	huffIndexLuminanceDC huffIndex = iota
		92  	huffIndexLuminanceAC
		93  	huffIndexChrominanceDC
		94  	huffIndexChrominanceAC
		95  	nHuffIndex
		96  )
		97  
		98  // huffmanSpec specifies a Huffman encoding.
		99  type huffmanSpec struct {
	 100  	// count[i] is the number of codes of length i bits.
	 101  	count [16]byte
	 102  	// value[i] is the decoded value of the i'th codeword.
	 103  	value []byte
	 104  }
	 105  
	 106  // theHuffmanSpec is the Huffman encoding specifications.
	 107  // This encoder uses the same Huffman encoding for all images.
	 108  var theHuffmanSpec = [nHuffIndex]huffmanSpec{
	 109  	// Luminance DC.
	 110  	{
	 111  		[16]byte{0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0},
	 112  		[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
	 113  	},
	 114  	// Luminance AC.
	 115  	{
	 116  		[16]byte{0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125},
	 117  		[]byte{
	 118  			0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
	 119  			0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
	 120  			0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
	 121  			0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
	 122  			0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
	 123  			0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
	 124  			0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
	 125  			0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
	 126  			0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
	 127  			0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
	 128  			0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
	 129  			0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
	 130  			0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
	 131  			0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	 132  			0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
	 133  			0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
	 134  			0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
	 135  			0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
	 136  			0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
	 137  			0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
	 138  			0xf9, 0xfa,
	 139  		},
	 140  	},
	 141  	// Chrominance DC.
	 142  	{
	 143  		[16]byte{0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
	 144  		[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
	 145  	},
	 146  	// Chrominance AC.
	 147  	{
	 148  		[16]byte{0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119},
	 149  		[]byte{
	 150  			0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
	 151  			0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
	 152  			0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
	 153  			0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
	 154  			0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
	 155  			0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
	 156  			0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
	 157  			0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
	 158  			0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
	 159  			0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
	 160  			0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
	 161  			0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	 162  			0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
	 163  			0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
	 164  			0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
	 165  			0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
	 166  			0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
	 167  			0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
	 168  			0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
	 169  			0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
	 170  			0xf9, 0xfa,
	 171  		},
	 172  	},
	 173  }
	 174  
	 175  // huffmanLUT is a compiled look-up table representation of a huffmanSpec.
	 176  // Each value maps to a uint32 of which the 8 most significant bits hold the
	 177  // codeword size in bits and the 24 least significant bits hold the codeword.
	 178  // The maximum codeword size is 16 bits.
	 179  type huffmanLUT []uint32
	 180  
	 181  func (h *huffmanLUT) init(s huffmanSpec) {
	 182  	maxValue := 0
	 183  	for _, v := range s.value {
	 184  		if int(v) > maxValue {
	 185  			maxValue = int(v)
	 186  		}
	 187  	}
	 188  	*h = make([]uint32, maxValue+1)
	 189  	code, k := uint32(0), 0
	 190  	for i := 0; i < len(s.count); i++ {
	 191  		nBits := uint32(i+1) << 24
	 192  		for j := uint8(0); j < s.count[i]; j++ {
	 193  			(*h)[s.value[k]] = nBits | code
	 194  			code++
	 195  			k++
	 196  		}
	 197  		code <<= 1
	 198  	}
	 199  }
	 200  
	 201  // theHuffmanLUT are compiled representations of theHuffmanSpec.
	 202  var theHuffmanLUT [4]huffmanLUT
	 203  
	 204  func init() {
	 205  	for i, s := range theHuffmanSpec {
	 206  		theHuffmanLUT[i].init(s)
	 207  	}
	 208  }
	 209  
	 210  // writer is a buffered writer.
	 211  type writer interface {
	 212  	Flush() error
	 213  	io.Writer
	 214  	io.ByteWriter
	 215  }
	 216  
	 217  // encoder encodes an image to the JPEG format.
	 218  type encoder struct {
	 219  	// w is the writer to write to. err is the first error encountered during
	 220  	// writing. All attempted writes after the first error become no-ops.
	 221  	w	 writer
	 222  	err error
	 223  	// buf is a scratch buffer.
	 224  	buf [16]byte
	 225  	// bits and nBits are accumulated bits to write to w.
	 226  	bits, nBits uint32
	 227  	// quant is the scaled quantization tables, in zig-zag order.
	 228  	quant [nQuantIndex][blockSize]byte
	 229  }
	 230  
	 231  func (e *encoder) flush() {
	 232  	if e.err != nil {
	 233  		return
	 234  	}
	 235  	e.err = e.w.Flush()
	 236  }
	 237  
	 238  func (e *encoder) write(p []byte) {
	 239  	if e.err != nil {
	 240  		return
	 241  	}
	 242  	_, e.err = e.w.Write(p)
	 243  }
	 244  
	 245  func (e *encoder) writeByte(b byte) {
	 246  	if e.err != nil {
	 247  		return
	 248  	}
	 249  	e.err = e.w.WriteByte(b)
	 250  }
	 251  
	 252  // emit emits the least significant nBits bits of bits to the bit-stream.
	 253  // The precondition is bits < 1<<nBits && nBits <= 16.
	 254  func (e *encoder) emit(bits, nBits uint32) {
	 255  	nBits += e.nBits
	 256  	bits <<= 32 - nBits
	 257  	bits |= e.bits
	 258  	for nBits >= 8 {
	 259  		b := uint8(bits >> 24)
	 260  		e.writeByte(b)
	 261  		if b == 0xff {
	 262  			e.writeByte(0x00)
	 263  		}
	 264  		bits <<= 8
	 265  		nBits -= 8
	 266  	}
	 267  	e.bits, e.nBits = bits, nBits
	 268  }
	 269  
	 270  // emitHuff emits the given value with the given Huffman encoder.
	 271  func (e *encoder) emitHuff(h huffIndex, value int32) {
	 272  	x := theHuffmanLUT[h][value]
	 273  	e.emit(x&(1<<24-1), x>>24)
	 274  }
	 275  
	 276  // emitHuffRLE emits a run of runLength copies of value encoded with the given
	 277  // Huffman encoder.
	 278  func (e *encoder) emitHuffRLE(h huffIndex, runLength, value int32) {
	 279  	a, b := value, value
	 280  	if a < 0 {
	 281  		a, b = -value, value-1
	 282  	}
	 283  	var nBits uint32
	 284  	if a < 0x100 {
	 285  		nBits = uint32(bitCount[a])
	 286  	} else {
	 287  		nBits = 8 + uint32(bitCount[a>>8])
	 288  	}
	 289  	e.emitHuff(h, runLength<<4|int32(nBits))
	 290  	if nBits > 0 {
	 291  		e.emit(uint32(b)&(1<<nBits-1), nBits)
	 292  	}
	 293  }
	 294  
	 295  // writeMarkerHeader writes the header for a marker with the given length.
	 296  func (e *encoder) writeMarkerHeader(marker uint8, markerlen int) {
	 297  	e.buf[0] = 0xff
	 298  	e.buf[1] = marker
	 299  	e.buf[2] = uint8(markerlen >> 8)
	 300  	e.buf[3] = uint8(markerlen & 0xff)
	 301  	e.write(e.buf[:4])
	 302  }
	 303  
	 304  // writeDQT writes the Define Quantization Table marker.
	 305  func (e *encoder) writeDQT() {
	 306  	const markerlen = 2 + int(nQuantIndex)*(1+blockSize)
	 307  	e.writeMarkerHeader(dqtMarker, markerlen)
	 308  	for i := range e.quant {
	 309  		e.writeByte(uint8(i))
	 310  		e.write(e.quant[i][:])
	 311  	}
	 312  }
	 313  
	 314  // writeSOF0 writes the Start Of Frame (Baseline Sequential) marker.
	 315  func (e *encoder) writeSOF0(size image.Point, nComponent int) {
	 316  	markerlen := 8 + 3*nComponent
	 317  	e.writeMarkerHeader(sof0Marker, markerlen)
	 318  	e.buf[0] = 8 // 8-bit color.
	 319  	e.buf[1] = uint8(size.Y >> 8)
	 320  	e.buf[2] = uint8(size.Y & 0xff)
	 321  	e.buf[3] = uint8(size.X >> 8)
	 322  	e.buf[4] = uint8(size.X & 0xff)
	 323  	e.buf[5] = uint8(nComponent)
	 324  	if nComponent == 1 {
	 325  		e.buf[6] = 1
	 326  		// No subsampling for grayscale image.
	 327  		e.buf[7] = 0x11
	 328  		e.buf[8] = 0x00
	 329  	} else {
	 330  		for i := 0; i < nComponent; i++ {
	 331  			e.buf[3*i+6] = uint8(i + 1)
	 332  			// We use 4:2:0 chroma subsampling.
	 333  			e.buf[3*i+7] = "\x22\x11\x11"[i]
	 334  			e.buf[3*i+8] = "\x00\x01\x01"[i]
	 335  		}
	 336  	}
	 337  	e.write(e.buf[:3*(nComponent-1)+9])
	 338  }
	 339  
	 340  // writeDHT writes the Define Huffman Table marker.
	 341  func (e *encoder) writeDHT(nComponent int) {
	 342  	markerlen := 2
	 343  	specs := theHuffmanSpec[:]
	 344  	if nComponent == 1 {
	 345  		// Drop the Chrominance tables.
	 346  		specs = specs[:2]
	 347  	}
	 348  	for _, s := range specs {
	 349  		markerlen += 1 + 16 + len(s.value)
	 350  	}
	 351  	e.writeMarkerHeader(dhtMarker, markerlen)
	 352  	for i, s := range specs {
	 353  		e.writeByte("\x00\x10\x01\x11"[i])
	 354  		e.write(s.count[:])
	 355  		e.write(s.value)
	 356  	}
	 357  }
	 358  
	 359  // writeBlock writes a block of pixel data using the given quantization table,
	 360  // returning the post-quantized DC value of the DCT-transformed block. b is in
	 361  // natural (not zig-zag) order.
	 362  func (e *encoder) writeBlock(b *block, q quantIndex, prevDC int32) int32 {
	 363  	fdct(b)
	 364  	// Emit the DC delta.
	 365  	dc := div(b[0], 8*int32(e.quant[q][0]))
	 366  	e.emitHuffRLE(huffIndex(2*q+0), 0, dc-prevDC)
	 367  	// Emit the AC components.
	 368  	h, runLength := huffIndex(2*q+1), int32(0)
	 369  	for zig := 1; zig < blockSize; zig++ {
	 370  		ac := div(b[unzig[zig]], 8*int32(e.quant[q][zig]))
	 371  		if ac == 0 {
	 372  			runLength++
	 373  		} else {
	 374  			for runLength > 15 {
	 375  				e.emitHuff(h, 0xf0)
	 376  				runLength -= 16
	 377  			}
	 378  			e.emitHuffRLE(h, runLength, ac)
	 379  			runLength = 0
	 380  		}
	 381  	}
	 382  	if runLength > 0 {
	 383  		e.emitHuff(h, 0x00)
	 384  	}
	 385  	return dc
	 386  }
	 387  
	 388  // toYCbCr converts the 8x8 region of m whose top-left corner is p to its
	 389  // YCbCr values.
	 390  func toYCbCr(m image.Image, p image.Point, yBlock, cbBlock, crBlock *block) {
	 391  	b := m.Bounds()
	 392  	xmax := b.Max.X - 1
	 393  	ymax := b.Max.Y - 1
	 394  	for j := 0; j < 8; j++ {
	 395  		for i := 0; i < 8; i++ {
	 396  			r, g, b, _ := m.At(min(p.X+i, xmax), min(p.Y+j, ymax)).RGBA()
	 397  			yy, cb, cr := color.RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
	 398  			yBlock[8*j+i] = int32(yy)
	 399  			cbBlock[8*j+i] = int32(cb)
	 400  			crBlock[8*j+i] = int32(cr)
	 401  		}
	 402  	}
	 403  }
	 404  
	 405  // grayToY stores the 8x8 region of m whose top-left corner is p in yBlock.
	 406  func grayToY(m *image.Gray, p image.Point, yBlock *block) {
	 407  	b := m.Bounds()
	 408  	xmax := b.Max.X - 1
	 409  	ymax := b.Max.Y - 1
	 410  	pix := m.Pix
	 411  	for j := 0; j < 8; j++ {
	 412  		for i := 0; i < 8; i++ {
	 413  			idx := m.PixOffset(min(p.X+i, xmax), min(p.Y+j, ymax))
	 414  			yBlock[8*j+i] = int32(pix[idx])
	 415  		}
	 416  	}
	 417  }
	 418  
	 419  // rgbaToYCbCr is a specialized version of toYCbCr for image.RGBA images.
	 420  func rgbaToYCbCr(m *image.RGBA, p image.Point, yBlock, cbBlock, crBlock *block) {
	 421  	b := m.Bounds()
	 422  	xmax := b.Max.X - 1
	 423  	ymax := b.Max.Y - 1
	 424  	for j := 0; j < 8; j++ {
	 425  		sj := p.Y + j
	 426  		if sj > ymax {
	 427  			sj = ymax
	 428  		}
	 429  		offset := (sj-b.Min.Y)*m.Stride - b.Min.X*4
	 430  		for i := 0; i < 8; i++ {
	 431  			sx := p.X + i
	 432  			if sx > xmax {
	 433  				sx = xmax
	 434  			}
	 435  			pix := m.Pix[offset+sx*4:]
	 436  			yy, cb, cr := color.RGBToYCbCr(pix[0], pix[1], pix[2])
	 437  			yBlock[8*j+i] = int32(yy)
	 438  			cbBlock[8*j+i] = int32(cb)
	 439  			crBlock[8*j+i] = int32(cr)
	 440  		}
	 441  	}
	 442  }
	 443  
	 444  // yCbCrToYCbCr is a specialized version of toYCbCr for image.YCbCr images.
	 445  func yCbCrToYCbCr(m *image.YCbCr, p image.Point, yBlock, cbBlock, crBlock *block) {
	 446  	b := m.Bounds()
	 447  	xmax := b.Max.X - 1
	 448  	ymax := b.Max.Y - 1
	 449  	for j := 0; j < 8; j++ {
	 450  		sy := p.Y + j
	 451  		if sy > ymax {
	 452  			sy = ymax
	 453  		}
	 454  		for i := 0; i < 8; i++ {
	 455  			sx := p.X + i
	 456  			if sx > xmax {
	 457  				sx = xmax
	 458  			}
	 459  			yi := m.YOffset(sx, sy)
	 460  			ci := m.COffset(sx, sy)
	 461  			yBlock[8*j+i] = int32(m.Y[yi])
	 462  			cbBlock[8*j+i] = int32(m.Cb[ci])
	 463  			crBlock[8*j+i] = int32(m.Cr[ci])
	 464  		}
	 465  	}
	 466  }
	 467  
	 468  // scale scales the 16x16 region represented by the 4 src blocks to the 8x8
	 469  // dst block.
	 470  func scale(dst *block, src *[4]block) {
	 471  	for i := 0; i < 4; i++ {
	 472  		dstOff := (i&2)<<4 | (i&1)<<2
	 473  		for y := 0; y < 4; y++ {
	 474  			for x := 0; x < 4; x++ {
	 475  				j := 16*y + 2*x
	 476  				sum := src[i][j] + src[i][j+1] + src[i][j+8] + src[i][j+9]
	 477  				dst[8*y+x+dstOff] = (sum + 2) >> 2
	 478  			}
	 479  		}
	 480  	}
	 481  }
	 482  
	 483  // sosHeaderY is the SOS marker "\xff\xda" followed by 8 bytes:
	 484  //	- the marker length "\x00\x08",
	 485  //	- the number of components "\x01",
	 486  //	- component 1 uses DC table 0 and AC table 0 "\x01\x00",
	 487  //	- the bytes "\x00\x3f\x00". Section B.2.3 of the spec says that for
	 488  //		sequential DCTs, those bytes (8-bit Ss, 8-bit Se, 4-bit Ah, 4-bit Al)
	 489  //		should be 0x00, 0x3f, 0x00<<4 | 0x00.
	 490  var sosHeaderY = []byte{
	 491  	0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x00, 0x3f, 0x00,
	 492  }
	 493  
	 494  // sosHeaderYCbCr is the SOS marker "\xff\xda" followed by 12 bytes:
	 495  //	- the marker length "\x00\x0c",
	 496  //	- the number of components "\x03",
	 497  //	- component 1 uses DC table 0 and AC table 0 "\x01\x00",
	 498  //	- component 2 uses DC table 1 and AC table 1 "\x02\x11",
	 499  //	- component 3 uses DC table 1 and AC table 1 "\x03\x11",
	 500  //	- the bytes "\x00\x3f\x00". Section B.2.3 of the spec says that for
	 501  //		sequential DCTs, those bytes (8-bit Ss, 8-bit Se, 4-bit Ah, 4-bit Al)
	 502  //		should be 0x00, 0x3f, 0x00<<4 | 0x00.
	 503  var sosHeaderYCbCr = []byte{
	 504  	0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02,
	 505  	0x11, 0x03, 0x11, 0x00, 0x3f, 0x00,
	 506  }
	 507  
	 508  // writeSOS writes the StartOfScan marker.
	 509  func (e *encoder) writeSOS(m image.Image) {
	 510  	switch m.(type) {
	 511  	case *image.Gray:
	 512  		e.write(sosHeaderY)
	 513  	default:
	 514  		e.write(sosHeaderYCbCr)
	 515  	}
	 516  	var (
	 517  		// Scratch buffers to hold the YCbCr values.
	 518  		// The blocks are in natural (not zig-zag) order.
	 519  		b			block
	 520  		cb, cr [4]block
	 521  		// DC components are delta-encoded.
	 522  		prevDCY, prevDCCb, prevDCCr int32
	 523  	)
	 524  	bounds := m.Bounds()
	 525  	switch m := m.(type) {
	 526  	// TODO(wathiede): switch on m.ColorModel() instead of type.
	 527  	case *image.Gray:
	 528  		for y := bounds.Min.Y; y < bounds.Max.Y; y += 8 {
	 529  			for x := bounds.Min.X; x < bounds.Max.X; x += 8 {
	 530  				p := image.Pt(x, y)
	 531  				grayToY(m, p, &b)
	 532  				prevDCY = e.writeBlock(&b, 0, prevDCY)
	 533  			}
	 534  		}
	 535  	default:
	 536  		rgba, _ := m.(*image.RGBA)
	 537  		ycbcr, _ := m.(*image.YCbCr)
	 538  		for y := bounds.Min.Y; y < bounds.Max.Y; y += 16 {
	 539  			for x := bounds.Min.X; x < bounds.Max.X; x += 16 {
	 540  				for i := 0; i < 4; i++ {
	 541  					xOff := (i & 1) * 8
	 542  					yOff := (i & 2) * 4
	 543  					p := image.Pt(x+xOff, y+yOff)
	 544  					if rgba != nil {
	 545  						rgbaToYCbCr(rgba, p, &b, &cb[i], &cr[i])
	 546  					} else if ycbcr != nil {
	 547  						yCbCrToYCbCr(ycbcr, p, &b, &cb[i], &cr[i])
	 548  					} else {
	 549  						toYCbCr(m, p, &b, &cb[i], &cr[i])
	 550  					}
	 551  					prevDCY = e.writeBlock(&b, 0, prevDCY)
	 552  				}
	 553  				scale(&b, &cb)
	 554  				prevDCCb = e.writeBlock(&b, 1, prevDCCb)
	 555  				scale(&b, &cr)
	 556  				prevDCCr = e.writeBlock(&b, 1, prevDCCr)
	 557  			}
	 558  		}
	 559  	}
	 560  	// Pad the last byte with 1's.
	 561  	e.emit(0x7f, 7)
	 562  }
	 563  
	 564  // DefaultQuality is the default quality encoding parameter.
	 565  const DefaultQuality = 75
	 566  
	 567  // Options are the encoding parameters.
	 568  // Quality ranges from 1 to 100 inclusive, higher is better.
	 569  type Options struct {
	 570  	Quality int
	 571  }
	 572  
	 573  // Encode writes the Image m to w in JPEG 4:2:0 baseline format with the given
	 574  // options. Default parameters are used if a nil *Options is passed.
	 575  func Encode(w io.Writer, m image.Image, o *Options) error {
	 576  	b := m.Bounds()
	 577  	if b.Dx() >= 1<<16 || b.Dy() >= 1<<16 {
	 578  		return errors.New("jpeg: image is too large to encode")
	 579  	}
	 580  	var e encoder
	 581  	if ww, ok := w.(writer); ok {
	 582  		e.w = ww
	 583  	} else {
	 584  		e.w = bufio.NewWriter(w)
	 585  	}
	 586  	// Clip quality to [1, 100].
	 587  	quality := DefaultQuality
	 588  	if o != nil {
	 589  		quality = o.Quality
	 590  		if quality < 1 {
	 591  			quality = 1
	 592  		} else if quality > 100 {
	 593  			quality = 100
	 594  		}
	 595  	}
	 596  	// Convert from a quality rating to a scaling factor.
	 597  	var scale int
	 598  	if quality < 50 {
	 599  		scale = 5000 / quality
	 600  	} else {
	 601  		scale = 200 - quality*2
	 602  	}
	 603  	// Initialize the quantization tables.
	 604  	for i := range e.quant {
	 605  		for j := range e.quant[i] {
	 606  			x := int(unscaledQuant[i][j])
	 607  			x = (x*scale + 50) / 100
	 608  			if x < 1 {
	 609  				x = 1
	 610  			} else if x > 255 {
	 611  				x = 255
	 612  			}
	 613  			e.quant[i][j] = uint8(x)
	 614  		}
	 615  	}
	 616  	// Compute number of components based on input image type.
	 617  	nComponent := 3
	 618  	switch m.(type) {
	 619  	// TODO(wathiede): switch on m.ColorModel() instead of type.
	 620  	case *image.Gray:
	 621  		nComponent = 1
	 622  	}
	 623  	// Write the Start Of Image marker.
	 624  	e.buf[0] = 0xff
	 625  	e.buf[1] = 0xd8
	 626  	e.write(e.buf[:2])
	 627  	// Write the quantization tables.
	 628  	e.writeDQT()
	 629  	// Write the image dimensions.
	 630  	e.writeSOF0(b.Size(), nComponent)
	 631  	// Write the Huffman tables.
	 632  	e.writeDHT(nComponent)
	 633  	// Write the image data.
	 634  	e.writeSOS(m)
	 635  	// Write the End Of Image marker.
	 636  	e.buf[0] = 0xff
	 637  	e.buf[1] = 0xd9
	 638  	e.write(e.buf[:2])
	 639  	e.flush()
	 640  	return e.err
	 641  }
	 642
View as plain text