writer.go

     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  // div returns a/b rounded to the nearest integer, instead of rounded to zero.
    16  func div(a, b int32) int32 {
    17  	if a >= 0 {
    18  		return (a + (b >> 1)) / b
    19  	}
    20  	return -((-a + (b >> 1)) / b)
    21  }
    22  
    23  // bitCount counts the number of bits needed to hold an integer.
    24  var bitCount = [256]byte{
    25  	0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
    26  	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    27  	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    28  	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    29  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    30  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    31  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    32  	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    33  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    34  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    35  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    36  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    37  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    38  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    39  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    40  	8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    41  }
    42  
    43  type quantIndex int
    44  
    45  const (
    46  	quantIndexLuminance quantIndex = iota
    47  	quantIndexChrominance
    48  	nQuantIndex
    49  )
    50  
    51  // unscaledQuant are the unscaled quantization tables in zig-zag order. Each
    52  // encoder copies and scales the tables according to its quality parameter.
    53  // The values are derived from section K.1 of the spec, after converting from
    54  // natural to zig-zag order.
    55  var unscaledQuant = [nQuantIndex][blockSize]byte{
    56  	// Luminance.
    57  	{
    58  		16, 11, 12, 14, 12, 10, 16, 14,
    59  		13, 14, 18, 17, 16, 19, 24, 40,
    60  		26, 24, 22, 22, 24, 49, 35, 37,
    61  		29, 40, 58, 51, 61, 60, 57, 51,
    62  		56, 55, 64, 72, 92, 78, 64, 68,
    63  		87, 69, 55, 56, 80, 109, 81, 87,
    64  		95, 98, 103, 104, 103, 62, 77, 113,
    65  		121, 112, 100, 120, 92, 101, 103, 99,
    66  	},
    67  	// Chrominance.
    68  	{
    69  		17, 18, 18, 24, 21, 24, 47, 26,
    70  		26, 47, 99, 66, 56, 66, 99, 99,
    71  		99, 99, 99, 99, 99, 99, 99, 99,
    72  		99, 99, 99, 99, 99, 99, 99, 99,
    73  		99, 99, 99, 99, 99, 99, 99, 99,
    74  		99, 99, 99, 99, 99, 99, 99, 99,
    75  		99, 99, 99, 99, 99, 99, 99, 99,
    76  		99, 99, 99, 99, 99, 99, 99, 99,
    77  	},
    78  }
    79  
    80  type huffIndex int
    81  
    82  const (
    83  	huffIndexLuminanceDC huffIndex = iota
    84  	huffIndexLuminanceAC
    85  	huffIndexChrominanceDC
    86  	huffIndexChrominanceAC
    87  	nHuffIndex
    88  )
    89  
    90  // huffmanSpec specifies a Huffman encoding.
    91  type huffmanSpec struct {
    92  	// count[i] is the number of codes of length i+1 bits.
    93  	count [16]byte
    94  	// value[i] is the decoded value of the i'th codeword.
    95  	value []byte
    96  }
    97  
    98  // theHuffmanSpec is the Huffman encoding specifications.
    99  //
   100  // This encoder uses the same Huffman encoding for all images. It is also the
   101  // same Huffman encoding used by section K.3 of the spec.
   102  //
   103  // The DC tables have 12 decoded values, called categories.
   104  //
   105  // The AC tables have 162 decoded values: bytes that pack a 4-bit Run and a
   106  // 4-bit Size. There are 16 valid Runs and 10 valid Sizes, plus two special R|S
   107  // cases: 0|0 (meaning EOB) and F|0 (meaning ZRL).
   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