libgo/go/image/png/paeth_test.go

   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.
   4
   5 package png
   6
   7 import (
   8         "bytes"
   9         "math/rand"
  10         "testing"
  11 )
  12
  13 func abs(x int) int {
  14         if x < 0 {
  15                 return -x
  16         }
  17         return x
  18 }
  19
  20 // slowPaeth is a slow but simple implementation of the Paeth function.
  21 // It is a straight port of the sample code in the PNG spec, section 9.4.
  22 func slowPaeth(a, b, c uint8) uint8 {
  23         p := int(a) + int(b) - int(c)
  24         pa := abs(p - int(a))
  25         pb := abs(p - int(b))
  26         pc := abs(p - int(c))
  27         if pa <= pb && pa <= pc {
  28                 return a
  29         } else if pb <= pc {
  30                 return b
  31         }
  32         return c
  33 }
  34
  35 // slowFilterPaeth is a slow but simple implementation of func filterPaeth.
  36 func slowFilterPaeth(cdat, pdat []byte, bytesPerPixel int) {
  37         for i := 0; i < bytesPerPixel; i++ {
  38                 cdat[i] += paeth(0, pdat[i], 0)
  39         }
  40         for i := bytesPerPixel; i < len(cdat); i++ {
  41                 cdat[i] += paeth(cdat[i-bytesPerPixel], pdat[i], pdat[i-bytesPerPixel])
  42         }
  43 }
  44
  45 func TestPaeth(t *testing.T) {
  46         for a := 0; a < 256; a += 15 {
  47                 for b := 0; b < 256; b += 15 {
  48                         for c := 0; c < 256; c += 15 {
  49                                 got := paeth(uint8(a), uint8(b), uint8(c))
  50                                 want := slowPaeth(uint8(a), uint8(b), uint8(c))
  51                                 if got != want {
  52                                         t.Errorf("a, b, c = %d, %d, %d: got %d, want %d", a, b, c, got, want)
  53                                 }
  54                         }
  55                 }
  56         }
  57 }
  58
  59 func BenchmarkPaeth(b *testing.B) {
  60         for i := 0; i < b.N; i++ {
  61                 paeth(uint8(i>>16), uint8(i>>8), uint8(i))
  62         }
  63 }
  64
  65 func TestPaethDecode(t *testing.T) {
  66         pdat0 := make([]byte, 32)
  67         pdat1 := make([]byte, 32)
  68         pdat2 := make([]byte, 32)
  69         cdat0 := make([]byte, 32)
  70         cdat1 := make([]byte, 32)
  71         cdat2 := make([]byte, 32)
  72         r := rand.New(rand.NewSource(1))
  73         for bytesPerPixel := 1; bytesPerPixel <= 8; bytesPerPixel++ {
  74                 for i := 0; i < 100; i++ {
  75                         for j := range pdat0 {
  76                                 pdat0[j] = uint8(r.Uint32())
  77                                 cdat0[j] = uint8(r.Uint32())
  78                         }
  79                         copy(pdat1, pdat0)
  80                         copy(pdat2, pdat0)
  81                         copy(cdat1, cdat0)
  82                         copy(cdat2, cdat0)
  83                         filterPaeth(cdat1, pdat1, bytesPerPixel)
  84                         slowFilterPaeth(cdat2, pdat2, bytesPerPixel)
  85                         if !bytes.Equal(cdat1, cdat2) {
  86                                 t.Errorf("bytesPerPixel: %d\npdat0: % x\ncdat0: % x\ngot:   % x\nwant:  % x", bytesPerPixel, pdat0, cdat0, cdat1, cdat2)
  87                                 break
  88                         }
  89                 }
  90         }
  91 }