221 lines
6.1 KiB
Go
221 lines
6.1 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package jpeg
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"io/ioutil"
|
|
"math/rand"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// TestDecodeProgressive tests that decoding the baseline and progressive
|
|
// versions of the same image result in exactly the same pixel data, in YCbCr
|
|
// space for color images, and Y space for grayscale images.
|
|
func TestDecodeProgressive(t *testing.T) {
|
|
testCases := []string{
|
|
"../testdata/video-001",
|
|
"../testdata/video-001.q50.420",
|
|
"../testdata/video-001.q50.422",
|
|
"../testdata/video-001.q50.440",
|
|
"../testdata/video-001.q50.444",
|
|
"../testdata/video-005.gray.q50",
|
|
"../testdata/video-005.gray.q50.2x2",
|
|
}
|
|
for _, tc := range testCases {
|
|
m0, err := decodeFile(tc + ".jpeg")
|
|
if err != nil {
|
|
t.Errorf("%s: %v", tc+".jpeg", err)
|
|
continue
|
|
}
|
|
m1, err := decodeFile(tc + ".progressive.jpeg")
|
|
if err != nil {
|
|
t.Errorf("%s: %v", tc+".progressive.jpeg", err)
|
|
continue
|
|
}
|
|
if m0.Bounds() != m1.Bounds() {
|
|
t.Errorf("%s: bounds differ: %v and %v", tc, m0.Bounds(), m1.Bounds())
|
|
continue
|
|
}
|
|
switch m0 := m0.(type) {
|
|
case *image.YCbCr:
|
|
m1 := m1.(*image.YCbCr)
|
|
if err := check(m0.Bounds(), m0.Y, m1.Y, m0.YStride, m1.YStride); err != nil {
|
|
t.Errorf("%s (Y): %v", tc, err)
|
|
continue
|
|
}
|
|
if err := check(m0.Bounds(), m0.Cb, m1.Cb, m0.CStride, m1.CStride); err != nil {
|
|
t.Errorf("%s (Cb): %v", tc, err)
|
|
continue
|
|
}
|
|
if err := check(m0.Bounds(), m0.Cr, m1.Cr, m0.CStride, m1.CStride); err != nil {
|
|
t.Errorf("%s (Cr): %v", tc, err)
|
|
continue
|
|
}
|
|
case *image.Gray:
|
|
m1 := m1.(*image.Gray)
|
|
if err := check(m0.Bounds(), m0.Pix, m1.Pix, m0.Stride, m1.Stride); err != nil {
|
|
t.Errorf("%s: %v", tc, err)
|
|
continue
|
|
}
|
|
default:
|
|
t.Errorf("%s: unexpected image type %T", tc, m0)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func decodeFile(filename string) (image.Image, error) {
|
|
f, err := os.Open(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
return Decode(f)
|
|
|
|
}
|
|
|
|
// check checks that the two pix data are equal, within the given bounds.
|
|
func check(bounds image.Rectangle, pix0, pix1 []byte, stride0, stride1 int) error {
|
|
if len(pix0) != len(pix1) {
|
|
return fmt.Errorf("len(pix) %d and %d differ", len(pix0), len(pix1))
|
|
}
|
|
if stride0 != stride1 {
|
|
return fmt.Errorf("strides %d and %d differ", stride0, stride1)
|
|
}
|
|
if stride0%8 != 0 {
|
|
return fmt.Errorf("stride %d is not a multiple of 8", stride0)
|
|
}
|
|
// Compare the two pix data, one 8x8 block at a time.
|
|
for y := 0; y < len(pix0)/stride0; y += 8 {
|
|
for x := 0; x < stride0; x += 8 {
|
|
if x >= bounds.Max.X || y >= bounds.Max.Y {
|
|
// We don't care if the two pix data differ if the 8x8 block is
|
|
// entirely outside of the image's bounds. For example, this can
|
|
// occur with a 4:2:0 chroma subsampling and a 1x1 image. Baseline
|
|
// decoding works on the one 16x16 MCU as a whole; progressive
|
|
// decoding's first pass works on that 16x16 MCU as a whole but
|
|
// refinement passes only process one 8x8 block within the MCU.
|
|
continue
|
|
}
|
|
|
|
for j := 0; j < 8; j++ {
|
|
for i := 0; i < 8; i++ {
|
|
index := (y+j)*stride0 + (x + i)
|
|
if pix0[index] != pix1[index] {
|
|
return fmt.Errorf("blocks at (%d, %d) differ:\n%sand\n%s", x, y,
|
|
pixString(pix0, stride0, x, y),
|
|
pixString(pix1, stride1, x, y),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func pixString(pix []byte, stride, x, y int) string {
|
|
s := bytes.NewBuffer(nil)
|
|
for j := 0; j < 8; j++ {
|
|
fmt.Fprintf(s, "\t")
|
|
for i := 0; i < 8; i++ {
|
|
fmt.Fprintf(s, "%02x ", pix[(y+j)*stride+(x+i)])
|
|
}
|
|
fmt.Fprintf(s, "\n")
|
|
}
|
|
return s.String()
|
|
}
|
|
|
|
func TestExtraneousData(t *testing.T) {
|
|
// Encode a 1x1 red image.
|
|
src := image.NewRGBA(image.Rect(0, 0, 1, 1))
|
|
src.Set(0, 0, color.RGBA{0xff, 0x00, 0x00, 0xff})
|
|
buf := new(bytes.Buffer)
|
|
if err := Encode(buf, src, nil); err != nil {
|
|
t.Fatalf("encode: %v", err)
|
|
}
|
|
enc := buf.String()
|
|
// Sanity check that the encoded JPEG is long enough, that it ends in a
|
|
// "\xff\xd9" EOI marker, and that it contains a "\xff\xda" SOS marker
|
|
// somewhere in the final 64 bytes.
|
|
if len(enc) < 64 {
|
|
t.Fatalf("encoded JPEG is too short: %d bytes", len(enc))
|
|
}
|
|
if got, want := enc[len(enc)-2:], "\xff\xd9"; got != want {
|
|
t.Fatalf("encoded JPEG ends with %q, want %q", got, want)
|
|
}
|
|
if s := enc[len(enc)-64:]; !strings.Contains(s, "\xff\xda") {
|
|
t.Fatalf("encoded JPEG does not contain a SOS marker (ff da) near the end: % x", s)
|
|
}
|
|
// Test that adding some random junk between the SOS marker and the
|
|
// EOI marker does not affect the decoding.
|
|
rnd := rand.New(rand.NewSource(1))
|
|
for i, nerr := 0, 0; i < 1000 && nerr < 10; i++ {
|
|
buf.Reset()
|
|
// Write all but the trailing "\xff\xd9" EOI marker.
|
|
buf.WriteString(enc[:len(enc)-2])
|
|
// Write some random extraneous data.
|
|
for n := rnd.Intn(10); n > 0; n-- {
|
|
if x := byte(rnd.Intn(256)); x != 0xff {
|
|
buf.WriteByte(x)
|
|
} else {
|
|
// The JPEG format escapes a SOS 0xff data byte as "\xff\x00".
|
|
buf.WriteString("\xff\x00")
|
|
}
|
|
}
|
|
// Write the "\xff\xd9" EOI marker.
|
|
buf.WriteString("\xff\xd9")
|
|
|
|
// Check that we can still decode the resultant image.
|
|
got, err := Decode(buf)
|
|
if err != nil {
|
|
t.Errorf("could not decode image #%d: %v", i, err)
|
|
nerr++
|
|
continue
|
|
}
|
|
if got.Bounds() != src.Bounds() {
|
|
t.Errorf("image #%d, bounds differ: %v and %v", i, got.Bounds(), src.Bounds())
|
|
nerr++
|
|
continue
|
|
}
|
|
if averageDelta(got, src) > 2<<8 {
|
|
t.Errorf("image #%d changed too much after a round trip", i)
|
|
nerr++
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func benchmarkDecode(b *testing.B, filename string) {
|
|
b.StopTimer()
|
|
data, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
cfg, err := DecodeConfig(bytes.NewReader(data))
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
b.SetBytes(int64(cfg.Width * cfg.Height * 4))
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Decode(bytes.NewReader(data))
|
|
}
|
|
}
|
|
|
|
func BenchmarkDecodeBaseline(b *testing.B) {
|
|
benchmarkDecode(b, "../testdata/video-001.jpeg")
|
|
}
|
|
|
|
func BenchmarkDecodeProgressive(b *testing.B) {
|
|
benchmarkDecode(b, "../testdata/video-001.progressive.jpeg")
|
|
}
|