func TestDecodeFailsWithBlankFile(t *testing.T) {
blank := bytes.NewBuffer(nil)
_, err := jpeg.Decode(blank, &jpeg.DecoderOptions{})
if err == nil {
t.Errorf("got no error with blank file")
}
}
func main() {
flag.Parse()
file := flag.Arg(0)
io, err := os.Open(file)
if err != nil {
log.Fatalln("Can't open file: ", file)
}
img, err := jpeg.Decode(io, &jpeg.DecoderOptions{})
if img == nil {
log.Fatalln("Got nil")
}
if err != nil {
log.Fatalln("Got Error: %v", err)
}
//
// write your code here ...
//
switch img.(type) {
case *image.YCbCr:
log.Println("decoded YCbCr")
case *image.Gray:
log.Println("decoded Gray")
default:
log.Println("unknown format")
}
}
func TestDecodeAndEncodeSubsampledImages(t *testing.T) {
for _, file := range subsampledImageFiles {
r := util.OpenFile(file)
fmt.Printf(" - test: %s\n", file)
img, err := jpeg.Decode(r, &jpeg.DecoderOptions{})
if err != nil {
t.Errorf("Decode returns error: %v", err)
}
// Create output file
f, err := os.Create(util.GetOutFilePath(fmt.Sprintf("TestDecodeAndEncodeSubsampledImages_%s", file)))
if err != nil {
panic(err)
}
w := bufio.NewWriter(f)
defer func() {
w.Flush()
f.Close()
}()
if err := jpeg.Encode(w, img, &jpeg.EncoderOptions{Quality: 90}); err != nil {
t.Errorf("Encode returns error: %v", err)
}
}
}
func TestDecode(t *testing.T) {
for _, file := range naturalImageFiles {
io := util.OpenFile(file)
fmt.Printf(" - test: %s\n", file)
img, err := jpeg.Decode(io, &jpeg.DecoderOptions{})
if err != nil {
t.Errorf("Got Error: %v", err)
}
util.WritePNG(img, fmt.Sprintf("TestDecode_%s.png", file))
}
}
func BenchmarkDecode(b *testing.B) {
for i := 0; i < b.N; i++ {
for _, file := range naturalImageFiles {
io := util.OpenFile(file)
img, err := jpeg.Decode(io, &jpeg.DecoderOptions{})
if img == nil {
b.Error("Got nil")
}
if err != nil {
b.Errorf("Got Error: %v", err)
}
}
}
}
func TestEncodeGrayImage(t *testing.T) {
w, h := 400, 200
img := image.NewGray(image.Rect(0, 0, w, h))
// make gradient
for x := 0; x < w; x++ {
for y := 0; y < h; y++ {
img.SetGray(x, y, color.Gray{uint8(float64(x*y) / float64(w*h) * 255)})
}
}
// encode gray gradient
f, err := os.Create(util.GetOutFilePath(fmt.Sprintf("TestEncodeGrayImage_%dx%d.jpg", w, h)))
if err != nil {
panic(err)
}
wr := bufio.NewWriter(f)
defer func() {
wr.Flush()
f.Close()
}()
if err := jpeg.Encode(wr, img, &jpeg.EncoderOptions{Quality: 90}); err != nil {
t.Errorf("Encode returns error: %v", err)
}
wr.Flush()
// rewind to first
f.Seek(0, 0)
// decode file
decoded, err := jpeg.Decode(f, &jpeg.DecoderOptions{})
if err != nil {
t.Errorf("Decode returns error: %v", err)
}
for x := 0; x < w; x++ {
for y := 0; y < h; y++ {
r, g, b, _ := decoded.At(x, y).RGBA()
ref := uint32(float64(x*y) / float64(w*h) * 255)
if delta((r>>8), ref) > 1 || delta((g>>8), ref) > 1 || delta((b>>8), ref) > 1 {
t.Errorf("(%d, %d): got (%d, %d, %d) want %v", x, y, r, g, b, ref)
}
}
}
}
func TestDecodeScaled(t *testing.T) {
for _, file := range naturalImageFiles {
io := util.OpenFile(file)
fmt.Printf(" - test: %s\n", file)
img, err := jpeg.Decode(io, &jpeg.DecoderOptions{ScaleTarget: image.Rect(0, 0, 100, 100)})
if err != nil {
t.Errorf("Got Error: %v", err)
}
if got := img.Bounds().Dx(); got != 256 {
t.Errorf("Wrong scaled width: %v, expect: 128 (=1024/8)", got)
}
if got := img.Bounds().Dy(); got != 192 {
t.Errorf("Wrong scaled height: %v, expect: 192 (=768/8)", got)
}
util.WritePNG(img, fmt.Sprintf("TestDecodeScaled_%s.png", file))
}
}