1
2
3
4
5
6
7
8 package jpeg
9
10 import (
11 "image"
12 "image/color"
13 "image/internal/imageutil"
14 "io"
15 )
16
17
18
19
20
21 type FormatError string
22
23 func (e FormatError) Error() string { return "invalid JPEG format: " + string(e) }
24
25
26 type UnsupportedError string
27
28 func (e UnsupportedError) Error() string { return "unsupported JPEG feature: " + string(e) }
29
30 var errUnsupportedSubsamplingRatio = UnsupportedError("luma/chroma subsampling ratio")
31
32
33 type component struct {
34 h int
35 v int
36 c uint8
37 tq uint8
38 }
39
40 const (
41 dcTable = 0
42 acTable = 1
43 maxTc = 1
44 maxTh = 3
45 maxTq = 3
46
47 maxComponents = 4
48 )
49
50 const (
51 sof0Marker = 0xc0
52 sof1Marker = 0xc1
53 sof2Marker = 0xc2
54 dhtMarker = 0xc4
55 rst0Marker = 0xd0
56 rst7Marker = 0xd7
57 soiMarker = 0xd8
58 eoiMarker = 0xd9
59 sosMarker = 0xda
60 dqtMarker = 0xdb
61 driMarker = 0xdd
62 comMarker = 0xfe
63
64
65
66 app0Marker = 0xe0
67 app14Marker = 0xee
68 app15Marker = 0xef
69 )
70
71
72 const (
73 adobeTransformUnknown = 0
74 adobeTransformYCbCr = 1
75 adobeTransformYCbCrK = 2
76 )
77
78
79
80
81 var unzig = [blockSize]int{
82 0, 1, 8, 16, 9, 2, 3, 10,
83 17, 24, 32, 25, 18, 11, 4, 5,
84 12, 19, 26, 33, 40, 48, 41, 34,
85 27, 20, 13, 6, 7, 14, 21, 28,
86 35, 42, 49, 56, 57, 50, 43, 36,
87 29, 22, 15, 23, 30, 37, 44, 51,
88 58, 59, 52, 45, 38, 31, 39, 46,
89 53, 60, 61, 54, 47, 55, 62, 63,
90 }
91
92
93 type Reader interface {
94 io.ByteReader
95 io.Reader
96 }
97
98
99
100
101 type bits struct {
102 a uint32
103 m uint32
104 n int32
105 }
106
107 type decoder struct {
108 r io.Reader
109 bits bits
110
111
112
113 bytes struct {
114
115
116 buf [4096]byte
117 i, j int
118
119
120 nUnreadable int
121 }
122 width, height int
123
124 img1 *image.Gray
125 img3 *image.YCbCr
126 blackPix []byte
127 blackStride int
128
129 ri int
130 nComp int
131
132
133
134
135
136
137 baseline bool
138 progressive bool
139
140 jfif bool
141 adobeTransformValid bool
142 adobeTransform uint8
143 eobRun uint16
144
145 comp [maxComponents]component
146 progCoeffs [maxComponents][]block
147 huff [maxTc + 1][maxTh + 1]huffman
148 quant [maxTq + 1]block
149 tmp [2 * blockSize]byte
150 }
151
152
153
154 func (d *decoder) fill() error {
155 if d.bytes.i != d.bytes.j {
156 panic("jpeg: fill called when unread bytes exist")
157 }
158
159
160 if d.bytes.j > 2 {
161 d.bytes.buf[0] = d.bytes.buf[d.bytes.j-2]
162 d.bytes.buf[1] = d.bytes.buf[d.bytes.j-1]
163 d.bytes.i, d.bytes.j = 2, 2
164 }
165
166 n, err := d.r.Read(d.bytes.buf[d.bytes.j:])
167 d.bytes.j += n
168 if n > 0 {
169 err = nil
170 }
171 return err
172 }
173
174
175
176
177
178
179 func (d *decoder) unreadByteStuffedByte() {
180 d.bytes.i -= d.bytes.nUnreadable
181 d.bytes.nUnreadable = 0
182 if d.bits.n >= 8 {
183 d.bits.a >>= 8
184 d.bits.n -= 8
185 d.bits.m >>= 8
186 }
187 }
188
189
190
191 func (d *decoder) readByte() (x byte, err error) {
192 for d.bytes.i == d.bytes.j {
193 if err = d.fill(); err != nil {
194 return 0, err
195 }
196 }
197 x = d.bytes.buf[d.bytes.i]
198 d.bytes.i++
199 d.bytes.nUnreadable = 0
200 return x, nil
201 }
202
203
204
205 var errMissingFF00 = FormatError("missing 0xff00 sequence")
206
207
208 func (d *decoder) readByteStuffedByte() (x byte, err error) {
209
210 if d.bytes.i+2 <= d.bytes.j {
211 x = d.bytes.buf[d.bytes.i]
212 d.bytes.i++
213 d.bytes.nUnreadable = 1
214 if x != 0xff {
215 return x, err
216 }
217 if d.bytes.buf[d.bytes.i] != 0x00 {
218 return 0, errMissingFF00
219 }
220 d.bytes.i++
221 d.bytes.nUnreadable = 2
222 return 0xff, nil
223 }
224
225 d.bytes.nUnreadable = 0
226
227 x, err = d.readByte()
228 if err != nil {
229 return 0, err
230 }
231 d.bytes.nUnreadable = 1
232 if x != 0xff {
233 return x, nil
234 }
235
236 x, err = d.readByte()
237 if err != nil {
238 return 0, err
239 }
240 d.bytes.nUnreadable = 2
241 if x != 0x00 {
242 return 0, errMissingFF00
243 }
244 return 0xff, nil
245 }
246
247
248
249 func (d *decoder) readFull(p []byte) error {
250
251 if d.bytes.nUnreadable != 0 {
252 if d.bits.n >= 8 {
253 d.unreadByteStuffedByte()
254 }
255 d.bytes.nUnreadable = 0
256 }
257
258 for {
259 n := copy(p, d.bytes.buf[d.bytes.i:d.bytes.j])
260 p = p[n:]
261 d.bytes.i += n
262 if len(p) == 0 {
263 break
264 }
265 if err := d.fill(); err != nil {
266 if err == io.EOF {
267 err = io.ErrUnexpectedEOF
268 }
269 return err
270 }
271 }
272 return nil
273 }
274
275
276 func (d *decoder) ignore(n int) error {
277
278 if d.bytes.nUnreadable != 0 {
279 if d.bits.n >= 8 {
280 d.unreadByteStuffedByte()
281 }
282 d.bytes.nUnreadable = 0
283 }
284
285 for {
286 m := d.bytes.j - d.bytes.i
287 if m > n {
288 m = n
289 }
290 d.bytes.i += m
291 n -= m
292 if n == 0 {
293 break
294 }
295 if err := d.fill(); err != nil {
296 if err == io.EOF {
297 err = io.ErrUnexpectedEOF
298 }
299 return err
300 }
301 }
302 return nil
303 }
304
305
306 func (d *decoder) processSOF(n int) error {
307 if d.nComp != 0 {
308 return FormatError("multiple SOF markers")
309 }
310 switch n {
311 case 6 + 3*1:
312 d.nComp = 1
313 case 6 + 3*3:
314 d.nComp = 3
315 case 6 + 3*4:
316 d.nComp = 4
317 default:
318 return UnsupportedError("number of components")
319 }
320 if err := d.readFull(d.tmp[:n]); err != nil {
321 return err
322 }
323
324 if d.tmp[0] != 8 {
325 return UnsupportedError("precision")
326 }
327 d.height = int(d.tmp[1])<<8 + int(d.tmp[2])
328 d.width = int(d.tmp[3])<<8 + int(d.tmp[4])
329 if int(d.tmp[5]) != d.nComp {
330 return FormatError("SOF has wrong length")
331 }
332
333 for i := 0; i < d.nComp; i++ {
334 d.comp[i].c = d.tmp[6+3*i]
335
336
337 for j := 0; j < i; j++ {
338 if d.comp[i].c == d.comp[j].c {
339 return FormatError("repeated component identifier")
340 }
341 }
342
343 d.comp[i].tq = d.tmp[8+3*i]
344 if d.comp[i].tq > maxTq {
345 return FormatError("bad Tq value")
346 }
347
348 hv := d.tmp[7+3*i]
349 h, v := int(hv>>4), int(hv&0x0f)
350 if h < 1 || 4 < h || v < 1 || 4 < v {
351 return FormatError("luma/chroma subsampling ratio")
352 }
353 if h == 3 || v == 3 {
354 return errUnsupportedSubsamplingRatio
355 }
356 switch d.nComp {
357 case 1:
358
359
360
361
362
363
364
365
366
367
368
369 h, v = 1, 1
370
371 case 3:
372
373
374
375
376
377
378
379 switch i {
380 case 0:
381
382
383
384 if v == 4 {
385 return errUnsupportedSubsamplingRatio
386 }
387 case 1:
388 if d.comp[0].h%h != 0 || d.comp[0].v%v != 0 {
389 return errUnsupportedSubsamplingRatio
390 }
391 case 2:
392 if d.comp[1].h != h || d.comp[1].v != v {
393 return errUnsupportedSubsamplingRatio
394 }
395 }
396
397 case 4:
398
399
400
401
402
403
404
405
406
407 switch i {
408 case 0:
409 if hv != 0x11 && hv != 0x22 {
410 return errUnsupportedSubsamplingRatio
411 }
412 case 1, 2:
413 if hv != 0x11 {
414 return errUnsupportedSubsamplingRatio
415 }
416 case 3:
417 if d.comp[0].h != h || d.comp[0].v != v {
418 return errUnsupportedSubsamplingRatio
419 }
420 }
421 }
422
423 d.comp[i].h = h
424 d.comp[i].v = v
425 }
426 return nil
427 }
428
429
430 func (d *decoder) processDQT(n int) error {
431 loop:
432 for n > 0 {
433 n--
434 x, err := d.readByte()
435 if err != nil {
436 return err
437 }
438 tq := x & 0x0f
439 if tq > maxTq {
440 return FormatError("bad Tq value")
441 }
442 switch x >> 4 {
443 default:
444 return FormatError("bad Pq value")
445 case 0:
446 if n < blockSize {
447 break loop
448 }
449 n -= blockSize
450 if err := d.readFull(d.tmp[:blockSize]); err != nil {
451 return err
452 }
453 for i := range d.quant[tq] {
454 d.quant[tq][i] = int32(d.tmp[i])
455 }
456 case 1:
457 if n < 2*blockSize {
458 break loop
459 }
460 n -= 2 * blockSize
461 if err := d.readFull(d.tmp[:2*blockSize]); err != nil {
462 return err
463 }
464 for i := range d.quant[tq] {
465 d.quant[tq][i] = int32(d.tmp[2*i])<<8 | int32(d.tmp[2*i+1])
466 }
467 }
468 }
469 if n != 0 {
470 return FormatError("DQT has wrong length")
471 }
472 return nil
473 }
474
475
476 func (d *decoder) processDRI(n int) error {
477 if n != 2 {
478 return FormatError("DRI has wrong length")
479 }
480 if err := d.readFull(d.tmp[:2]); err != nil {
481 return err
482 }
483 d.ri = int(d.tmp[0])<<8 + int(d.tmp[1])
484 return nil
485 }
486
487 func (d *decoder) processApp0Marker(n int) error {
488 if n < 5 {
489 return d.ignore(n)
490 }
491 if err := d.readFull(d.tmp[:5]); err != nil {
492 return err
493 }
494 n -= 5
495
496 d.jfif = d.tmp[0] == 'J' && d.tmp[1] == 'F' && d.tmp[2] == 'I' && d.tmp[3] == 'F' && d.tmp[4] == '\x00'
497
498 if n > 0 {
499 return d.ignore(n)
500 }
501 return nil
502 }
503
504 func (d *decoder) processApp14Marker(n int) error {
505 if n < 12 {
506 return d.ignore(n)
507 }
508 if err := d.readFull(d.tmp[:12]); err != nil {
509 return err
510 }
511 n -= 12
512
513 if d.tmp[0] == 'A' && d.tmp[1] == 'd' && d.tmp[2] == 'o' && d.tmp[3] == 'b' && d.tmp[4] == 'e' {
514 d.adobeTransformValid = true
515 d.adobeTransform = d.tmp[11]
516 }
517
518 if n > 0 {
519 return d.ignore(n)
520 }
521 return nil
522 }
523
524
525 func (d *decoder) decode(r io.Reader, configOnly bool) (image.Image, error) {
526 d.r = r
527
528
529 if err := d.readFull(d.tmp[:2]); err != nil {
530 return nil, err
531 }
532 if d.tmp[0] != 0xff || d.tmp[1] != soiMarker {
533 return nil, FormatError("missing SOI marker")
534 }
535
536
537 for {
538 err := d.readFull(d.tmp[:2])
539 if err != nil {
540 return nil, err
541 }
542 for d.tmp[0] != 0xff {
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563 d.tmp[0] = d.tmp[1]
564 d.tmp[1], err = d.readByte()
565 if err != nil {
566 return nil, err
567 }
568 }
569 marker := d.tmp[1]
570 if marker == 0 {
571
572 continue
573 }
574 for marker == 0xff {
575
576
577 marker, err = d.readByte()
578 if err != nil {
579 return nil, err
580 }
581 }
582 if marker == eoiMarker {
583 break
584 }
585 if rst0Marker <= marker && marker <= rst7Marker {
586
587
588
589
590
591
592 continue
593 }
594
595
596
597 if err = d.readFull(d.tmp[:2]); err != nil {
598 return nil, err
599 }
600 n := int(d.tmp[0])<<8 + int(d.tmp[1]) - 2
601 if n < 0 {
602 return nil, FormatError("short segment length")
603 }
604
605 switch marker {
606 case sof0Marker, sof1Marker, sof2Marker:
607 d.baseline = marker == sof0Marker
608 d.progressive = marker == sof2Marker
609 err = d.processSOF(n)
610 if configOnly && d.jfif {
611 return nil, err
612 }
613 case dhtMarker:
614 if configOnly {
615 err = d.ignore(n)
616 } else {
617 err = d.processDHT(n)
618 }
619 case dqtMarker:
620 if configOnly {
621 err = d.ignore(n)
622 } else {
623 err = d.processDQT(n)
624 }
625 case sosMarker:
626 if configOnly {
627 return nil, nil
628 }
629 err = d.processSOS(n)
630 case driMarker:
631 if configOnly {
632 err = d.ignore(n)
633 } else {
634 err = d.processDRI(n)
635 }
636 case app0Marker:
637 err = d.processApp0Marker(n)
638 case app14Marker:
639 err = d.processApp14Marker(n)
640 default:
641 if app0Marker <= marker && marker <= app15Marker || marker == comMarker {
642 err = d.ignore(n)
643 } else if marker < 0xc0 {
644 err = FormatError("unknown marker")
645 } else {
646 err = UnsupportedError("unknown marker")
647 }
648 }
649 if err != nil {
650 return nil, err
651 }
652 }
653
654 if d.progressive {
655 if err := d.reconstructProgressiveImage(); err != nil {
656 return nil, err
657 }
658 }
659 if d.img1 != nil {
660 return d.img1, nil
661 }
662 if d.img3 != nil {
663 if d.blackPix != nil {
664 return d.applyBlack()
665 } else if d.isRGB() {
666 return d.convertToRGB()
667 }
668 return d.img3, nil
669 }
670 return nil, FormatError("missing SOS marker")
671 }
672
673
674
675
676
677
678
679
680 func (d *decoder) applyBlack() (image.Image, error) {
681 if !d.adobeTransformValid {
682 return nil, UnsupportedError("unknown color model: 4-component JPEG doesn't have Adobe APP14 metadata")
683 }
684
685
686
687
688
689 if d.adobeTransform != adobeTransformUnknown {
690
691
692
693
694 bounds := d.img3.Bounds()
695 img := image.NewRGBA(bounds)
696 imageutil.DrawYCbCr(img, bounds, d.img3, bounds.Min)
697 for iBase, y := 0, bounds.Min.Y; y < bounds.Max.Y; iBase, y = iBase+img.Stride, y+1 {
698 for i, x := iBase+3, bounds.Min.X; x < bounds.Max.X; i, x = i+4, x+1 {
699 img.Pix[i] = 255 - d.blackPix[(y-bounds.Min.Y)*d.blackStride+(x-bounds.Min.X)]
700 }
701 }
702 return &image.CMYK{
703 Pix: img.Pix,
704 Stride: img.Stride,
705 Rect: img.Rect,
706 }, nil
707 }
708
709
710
711
712
713
714 bounds := d.img3.Bounds()
715 img := image.NewCMYK(bounds)
716
717 translations := [4]struct {
718 src []byte
719 stride int
720 }{
721 {d.img3.Y, d.img3.YStride},
722 {d.img3.Cb, d.img3.CStride},
723 {d.img3.Cr, d.img3.CStride},
724 {d.blackPix, d.blackStride},
725 }
726 for t, translation := range translations {
727 subsample := d.comp[t].h != d.comp[0].h || d.comp[t].v != d.comp[0].v
728 for iBase, y := 0, bounds.Min.Y; y < bounds.Max.Y; iBase, y = iBase+img.Stride, y+1 {
729 sy := y - bounds.Min.Y
730 if subsample {
731 sy /= 2
732 }
733 for i, x := iBase+t, bounds.Min.X; x < bounds.Max.X; i, x = i+4, x+1 {
734 sx := x - bounds.Min.X
735 if subsample {
736 sx /= 2
737 }
738 img.Pix[i] = 255 - translation.src[sy*translation.stride+sx]
739 }
740 }
741 }
742 return img, nil
743 }
744
745 func (d *decoder) isRGB() bool {
746 if d.jfif {
747 return false
748 }
749 if d.adobeTransformValid && d.adobeTransform == adobeTransformUnknown {
750
751
752 return true
753 }
754 return d.comp[0].c == 'R' && d.comp[1].c == 'G' && d.comp[2].c == 'B'
755 }
756
757 func (d *decoder) convertToRGB() (image.Image, error) {
758 cScale := d.comp[0].h / d.comp[1].h
759 bounds := d.img3.Bounds()
760 img := image.NewRGBA(bounds)
761 for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
762 po := img.PixOffset(bounds.Min.X, y)
763 yo := d.img3.YOffset(bounds.Min.X, y)
764 co := d.img3.COffset(bounds.Min.X, y)
765 for i, iMax := 0, bounds.Max.X-bounds.Min.X; i < iMax; i++ {
766 img.Pix[po+4*i+0] = d.img3.Y[yo+i]
767 img.Pix[po+4*i+1] = d.img3.Cb[co+i/cScale]
768 img.Pix[po+4*i+2] = d.img3.Cr[co+i/cScale]
769 img.Pix[po+4*i+3] = 255
770 }
771 }
772 return img, nil
773 }
774
775
776 func Decode(r io.Reader) (image.Image, error) {
777 var d decoder
778 return d.decode(r, false)
779 }
780
781
782
783 func DecodeConfig(r io.Reader) (image.Config, error) {
784 var d decoder
785 if _, err := d.decode(r, true); err != nil {
786 return image.Config{}, err
787 }
788 switch d.nComp {
789 case 1:
790 return image.Config{
791 ColorModel: color.GrayModel,
792 Width: d.width,
793 Height: d.height,
794 }, nil
795 case 3:
796 cm := color.YCbCrModel
797 if d.isRGB() {
798 cm = color.RGBAModel
799 }
800 return image.Config{
801 ColorModel: cm,
802 Width: d.width,
803 Height: d.height,
804 }, nil
805 case 4:
806 return image.Config{
807 ColorModel: color.CMYKModel,
808 Width: d.width,
809 Height: d.height,
810 }, nil
811 }
812 return image.Config{}, FormatError("missing SOF marker")
813 }
814
815 func init() {
816 image.RegisterFormat("jpeg", "\xff\xd8", Decode, DecodeConfig)
817 }
818
View as plain text