1 // Copyright 2012 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.
11 // makeImg allocates and initializes the destination image.
12 func (d
*decoder
) makeImg(mxx
, myy
int) {
14 m
:= image
.NewGray(image
.Rect(0, 0, 8*mxx
, 8*myy
))
15 d
.img1
= m
.SubImage(image
.Rect(0, 0, d
.width
, d
.height
)).(*image
.Gray
)
21 hRatio
:= h0
/ d
.comp
[1].h
22 vRatio
:= v0
/ d
.comp
[1].v
23 var subsampleRatio image
.YCbCrSubsampleRatio
24 switch hRatio
<<4 | vRatio
{
26 subsampleRatio
= image
.YCbCrSubsampleRatio444
28 subsampleRatio
= image
.YCbCrSubsampleRatio440
30 subsampleRatio
= image
.YCbCrSubsampleRatio422
32 subsampleRatio
= image
.YCbCrSubsampleRatio420
34 subsampleRatio
= image
.YCbCrSubsampleRatio411
36 subsampleRatio
= image
.YCbCrSubsampleRatio410
40 m
:= image
.NewYCbCr(image
.Rect(0, 0, 8*h0
*mxx
, 8*v0
*myy
), subsampleRatio
)
41 d
.img3
= m
.SubImage(image
.Rect(0, 0, d
.width
, d
.height
)).(*image
.YCbCr
)
44 h3
, v3
:= d
.comp
[3].h
, d
.comp
[3].v
45 d
.blackPix
= make([]byte, 8*h3
*mxx
*8*v3
*myy
)
46 d
.blackStride
= 8 * h3
* mxx
50 // Specified in section B.2.3.
51 func (d
*decoder
) processSOS(n
int) error
{
53 return FormatError("missing SOF marker")
55 if n
< 6 ||
4+2*d
.nComp
< n || n%2
!= 0 {
56 return FormatError("SOS has wrong length")
58 if err
:= d
.readFull(d
.tmp
[:n
]); err
!= nil {
61 nComp
:= int(d
.tmp
[0])
63 return FormatError("SOS length inconsistent with number of components")
65 var scan
[maxComponents
]struct {
67 td
uint8 // DC table selector.
68 ta
uint8 // AC table selector.
71 for i
:= 0; i
< nComp
; i
++ {
72 cs
:= d
.tmp
[1+2*i
] // Component selector.
74 for j
, comp
:= range d
.comp
[:d
.nComp
] {
80 return FormatError("unknown component selector")
82 scan
[i
].compIndex
= uint8(compIndex
)
83 // Section B.2.3 states that "the value of Cs_j shall be different from
84 // the values of Cs_1 through Cs_(j-1)". Since we have previously
85 // verified that a frame's component identifiers (C_i values in section
86 // B.2.2) are unique, it suffices to check that the implicit indexes
87 // into d.comp are unique.
88 for j
:= 0; j
< i
; j
++ {
89 if scan
[i
].compIndex
== scan
[j
].compIndex
{
90 return FormatError("repeated component selector")
93 totalHV
+= d
.comp
[compIndex
].h
* d
.comp
[compIndex
].v
95 // The baseline t <= 1 restriction is specified in table B.3.
96 scan
[i
].td
= d
.tmp
[2+2*i
] >> 4
97 if t
:= scan
[i
].td
; t
> maxTh ||
(d
.baseline
&& t
> 1) {
98 return FormatError("bad Td value")
100 scan
[i
].ta
= d
.tmp
[2+2*i
] & 0x0f
101 if t
:= scan
[i
].ta
; t
> maxTh ||
(d
.baseline
&& t
> 1) {
102 return FormatError("bad Ta value")
105 // Section B.2.3 states that if there is more than one component then the
106 // total H*V values in a scan must be <= 10.
107 if d
.nComp
> 1 && totalHV
> 10 {
108 return FormatError("total sampling factors too large")
111 // zigStart and zigEnd are the spectral selection bounds.
112 // ah and al are the successive approximation high and low values.
113 // The spec calls these values Ss, Se, Ah and Al.
115 // For progressive JPEGs, these are the two more-or-less independent
116 // aspects of progression. Spectral selection progression is when not
117 // all of a block's 64 DCT coefficients are transmitted in one pass.
118 // For example, three passes could transmit coefficient 0 (the DC
119 // component), coefficients 1-5, and coefficients 6-63, in zig-zag
120 // order. Successive approximation is when not all of the bits of a
121 // band of coefficients are transmitted in one pass. For example,
122 // three passes could transmit the 6 most significant bits, followed
123 // by the second-least significant bit, followed by the least
126 // For sequential JPEGs, these parameters are hard-coded to 0/63/0/0, as
128 zigStart
, zigEnd
, ah
, al
:= int32(0), int32(blockSize
-1), uint32(0), uint32(0)
130 zigStart
= int32(d
.tmp
[1+2*nComp
])
131 zigEnd
= int32(d
.tmp
[2+2*nComp
])
132 ah
= uint32(d
.tmp
[3+2*nComp
] >> 4)
133 al
= uint32(d
.tmp
[3+2*nComp
] & 0x0f)
134 if (zigStart
== 0 && zigEnd
!= 0) || zigStart
> zigEnd || blockSize
<= zigEnd
{
135 return FormatError("bad spectral selection bounds")
137 if zigStart
!= 0 && nComp
!= 1 {
138 return FormatError("progressive AC coefficients for more than one component")
140 if ah
!= 0 && ah
!= al
+1 {
141 return FormatError("bad successive approximation values")
145 // mxx and myy are the number of MCUs (Minimum Coded Units) in the image.
146 h0
, v0
:= d
.comp
[0].h
, d
.comp
[0].v
// The h and v values from the Y components.
147 mxx
:= (d
.width
+ 8*h0
- 1) / (8 * h0
)
148 myy
:= (d
.height
+ 8*v0
- 1) / (8 * v0
)
149 if d
.img1
== nil && d
.img3
== nil {
153 for i
:= 0; i
< nComp
; i
++ {
154 compIndex
:= scan
[i
].compIndex
155 if d
.progCoeffs
[compIndex
] == nil {
156 d
.progCoeffs
[compIndex
] = make([]block
, mxx
*myy
*d
.comp
[compIndex
].h
*d
.comp
[compIndex
].v
)
162 mcu
, expectedRST
:= 0, uint8(rst0Marker
)
164 // b is the decoded coefficients, in natural (not zig-zag) order.
166 dc
[maxComponents
]int32
167 // bx and by are the location of the current block, in units of 8x8
168 // blocks: the third block in the first row has (bx, by) = (2, 0).
172 for my
:= 0; my
< myy
; my
++ {
173 for mx
:= 0; mx
< mxx
; mx
++ {
174 for i
:= 0; i
< nComp
; i
++ {
175 compIndex
:= scan
[i
].compIndex
176 hi
:= d
.comp
[compIndex
].h
177 vi
:= d
.comp
[compIndex
].v
178 for j
:= 0; j
< hi
*vi
; j
++ {
179 // The blocks are traversed one MCU at a time. For 4:2:0 chroma
180 // subsampling, there are four Y 8x8 blocks in every 16x16 MCU.
182 // For a sequential 32x16 pixel image, the Y blocks visiting order is:
186 // For progressive images, the interleaved scans (those with nComp > 1)
187 // are traversed as above, but non-interleaved scans are traversed left
188 // to right, top to bottom:
191 // Only DC scans (zigStart == 0) can be interleaved. AC scans must have
192 // only one component.
194 // To further complicate matters, for non-interleaved scans, there is no
195 // data for any blocks that are inside the image at the MCU level but
196 // outside the image at the pixel level. For example, a 24x16 pixel 4:2:0
197 // progressive image consists of two 16x16 MCUs. The interleaved scans
198 // will process 8 Y blocks:
201 // The non-interleaved scans will process only 6 Y blocks:
212 if bx
*8 >= d
.width || by
*8 >= d
.height
{
217 // Load the previous partially decoded coefficients, if applicable.
219 b
= d
.progCoeffs
[compIndex
][by
*mxx
*hi
+bx
]
225 if err
:= d
.refine(&b
, &d
.huff
[acTable
][scan
[i
].ta
], zigStart
, zigEnd
, 1<<al
); err
!= nil {
232 // Decode the DC coefficient, as specified in section F.2.2.1.
233 value
, err
:= d
.decodeHuffman(&d
.huff
[dcTable
][scan
[i
].td
])
238 return UnsupportedError("excessive DC component")
240 dcDelta
, err
:= d
.receiveExtend(value
)
244 dc
[compIndex
] += dcDelta
245 b
[0] = dc
[compIndex
] << al
248 if zig
<= zigEnd
&& d
.eobRun
> 0 {
251 // Decode the AC coefficients, as specified in section F.2.2.2.
252 huff
:= &d
.huff
[acTable
][scan
[i
].ta
]
253 for ; zig
<= zigEnd
; zig
++ {
254 value
, err
:= d
.decodeHuffman(huff
)
265 ac
, err
:= d
.receiveExtend(val1
)
269 b
[unzig
[zig
]] = ac
<< al
272 d
.eobRun
= uint16(1 << val0
)
274 bits
, err
:= d
.decodeBits(int32(val0
))
278 d
.eobRun |
= uint16(bits
)
290 // Save the coefficients.
291 d
.progCoeffs
[compIndex
][by
*mxx
*hi
+bx
] = b
292 // At this point, we could call reconstructBlock to dequantize and perform the
293 // inverse DCT, to save early stages of a progressive image to the *image.YCbCr
294 // buffers (the whole point of progressive encoding), but in Go, the jpeg.Decode
295 // function does not return until the entire image is decoded, so we "continue"
296 // here to avoid wasted computation. Instead, reconstructBlock is called on each
297 // accumulated block by the reconstructProgressiveImage method after all of the
298 // SOS markers are processed.
301 if err
:= d
.reconstructBlock(&b
, bx
, by
, int(compIndex
)); err
!= nil {
307 if d
.ri
> 0 && mcu%d
.ri
== 0 && mcu
< mxx
*myy
{
308 // A more sophisticated decoder could use RST[0-7] markers to resynchronize from corrupt input,
309 // but this one assumes well-formed input, and hence the restart marker follows immediately.
310 if err
:= d
.readFull(d
.tmp
[:2]); err
!= nil {
314 // Section F.1.2.3 says that "Byte alignment of markers is
315 // achieved by padding incomplete bytes with 1-bits. If padding
316 // with 1-bits creates a X’FF’ value, a zero byte is stuffed
317 // before adding the marker."
319 // Seeing "\xff\x00" here is not spec compliant, as we are not
320 // expecting an *incomplete* byte (that needed padding). Still,
321 // some real world encoders (see golang.org/issue/28717) insert
322 // it, so we accept it and re-try the 2 byte read.
324 // libjpeg issues a warning (but not an error) for this:
325 // https://github.com/LuaDist/libjpeg/blob/6c0fcb8ddee365e7abc4d332662b06900612e923/jdmarker.c#L1041-L1046
326 if d
.tmp
[0] == 0xff && d
.tmp
[1] == 0x00 {
327 if err
:= d
.readFull(d
.tmp
[:2]); err
!= nil {
332 if d
.tmp
[0] != 0xff || d
.tmp
[1] != expectedRST
{
333 return FormatError("bad RST marker")
336 if expectedRST
== rst7Marker
+1 {
337 expectedRST
= rst0Marker
339 // Reset the Huffman decoder.
341 // Reset the DC components, as per section F.2.1.3.1.
342 dc
= [maxComponents
]int32{}
343 // Reset the progressive decoder state, as per section G.1.2.2.
352 // refine decodes a successive approximation refinement block, as specified in
354 func (d
*decoder
) refine(b
*block
, h
*huffman
, zigStart
, zigEnd
, delta
int32) error
{
355 // Refining a DC component is trivial.
360 bit
, err
:= d
.decodeBit()
370 // Refining AC components is more complicated; see sections G.1.2.2 and G.1.2.3.
374 for ; zig
<= zigEnd
; zig
++ {
376 value
, err
:= d
.decodeHuffman(h
)
386 d
.eobRun
= uint16(1 << val0
)
388 bits
, err
:= d
.decodeBits(int32(val0
))
392 d
.eobRun |
= uint16(bits
)
398 bit
, err
:= d
.decodeBit()
406 return FormatError("unexpected Huffman code")
409 zig
, err
= d
.refineNonZeroes(b
, zig
, zigEnd
, int32(val0
), delta
)
414 return FormatError("too many coefficients")
423 if _
, err
:= d
.refineNonZeroes(b
, zig
, zigEnd
, -1, delta
); err
!= nil {
430 // refineNonZeroes refines non-zero entries of b in zig-zag order. If nz >= 0,
431 // the first nz zero entries are skipped over.
432 func (d
*decoder
) refineNonZeroes(b
*block
, zig
, zigEnd
, nz
, delta
int32) (int32, error
) {
433 for ; zig
<= zigEnd
; zig
++ {
442 bit
, err
:= d
.decodeBit()
458 func (d
*decoder
) reconstructProgressiveImage() error
{
459 // The h0, mxx, by and bx variables have the same meaning as in the
460 // processSOS method.
462 mxx
:= (d
.width
+ 8*h0
- 1) / (8 * h0
)
463 for i
:= 0; i
< d
.nComp
; i
++ {
464 if d
.progCoeffs
[i
] == nil {
467 v
:= 8 * d
.comp
[0].v
/ d
.comp
[i
].v
468 h
:= 8 * d
.comp
[0].h
/ d
.comp
[i
].h
469 stride
:= mxx
* d
.comp
[i
].h
470 for by
:= 0; by
*v
< d
.height
; by
++ {
471 for bx
:= 0; bx
*h
< d
.width
; bx
++ {
472 if err
:= d
.reconstructBlock(&d
.progCoeffs
[i
][by
*stride
+bx
], bx
, by
, i
); err
!= nil {
481 // reconstructBlock dequantizes, performs the inverse DCT and stores the block
483 func (d
*decoder
) reconstructBlock(b
*block
, bx
, by
, compIndex
int) error
{
484 qt
:= &d
.quant
[d
.comp
[compIndex
].tq
]
485 for zig
:= 0; zig
< blockSize
; zig
++ {
486 b
[unzig
[zig
]] *= qt
[zig
]
489 dst
, stride
:= []byte(nil), 0
491 dst
, stride
= d
.img1
.Pix
[8*(by
*d
.img1
.Stride
+bx
):], d
.img1
.Stride
495 dst
, stride
= d
.img3
.Y
[8*(by
*d
.img3
.YStride
+bx
):], d
.img3
.YStride
497 dst
, stride
= d
.img3
.Cb
[8*(by
*d
.img3
.CStride
+bx
):], d
.img3
.CStride
499 dst
, stride
= d
.img3
.Cr
[8*(by
*d
.img3
.CStride
+bx
):], d
.img3
.CStride
501 dst
, stride
= d
.blackPix
[8*(by
*d
.blackStride
+bx
):], d
.blackStride
503 return UnsupportedError("too many components")
506 // Level shift by +128, clip to [0, 255], and write to dst.
507 for y
:= 0; y
< 8; y
++ {
509 yStride
:= y
* stride
510 for x
:= 0; x
< 8; x
++ {
519 dst
[yStride
+x
] = uint8(c
)