writer.mx raw
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 = []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