libgo/go/image/format.go

   1 // Copyright 2010 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 image
   6
   7 import (
   8         "bufio"
   9         "errors"
  10         "io"
  11 )
  12
  13 // ErrFormat indicates that decoding encountered an unknown format.
  14 var ErrFormat = errors.New("image: unknown format")
  15
  16 // A format holds an image format's name, magic header and how to decode it.
  17 type format struct {
  18         name, magic  string
  19         decode       func(io.Reader) (Image, error)
  20         decodeConfig func(io.Reader) (Config, error)
  21 }
  22
  23 // Formats is the list of registered formats.
  24 var formats []format
  25
  26 // RegisterFormat registers an image format for use by Decode.
  27 // Name is the name of the format, like "jpeg" or "png".
  28 // Magic is the magic prefix that identifies the format's encoding. The magic
  29 // string can contain "?" wildcards that each match any one byte.
  30 // Decode is the function that decodes the encoded image.
  31 // DecodeConfig is the function that decodes just its configuration.
  32 func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error)) {
  33         formats = append(formats, format{name, magic, decode, decodeConfig})
  34 }
  35
  36 // A reader is an io.Reader that can also peek ahead.
  37 type reader interface {
  38         io.Reader
  39         Peek(int) ([]byte, error)
  40 }
  41
  42 // asReader converts an io.Reader to a reader.
  43 func asReader(r io.Reader) reader {
  44         if rr, ok := r.(reader); ok {
  45                 return rr
  46         }
  47         return bufio.NewReader(r)
  48 }
  49
  50 // Match reports whether magic matches b. Magic may contain "?" wildcards.
  51 func match(magic string, b []byte) bool {
  52         if len(magic) != len(b) {
  53                 return false
  54         }
  55         for i, c := range b {
  56                 if magic[i] != c && magic[i] != '?' {
  57                         return false
  58                 }
  59         }
  60         return true
  61 }
  62
  63 // Sniff determines the format of r's data.
  64 func sniff(r reader) format {
  65         for _, f := range formats {
  66                 b, err := r.Peek(len(f.magic))
  67                 if err == nil && match(f.magic, b) {
  68                         return f
  69                 }
  70         }
  71         return format{}
  72 }
  73
  74 // Decode decodes an image that has been encoded in a registered format.
  75 // The string returned is the format name used during format registration.
  76 // Format registration is typically done by an init function in the codec-
  77 // specific package.
  78 func Decode(r io.Reader) (Image, string, error) {
  79         rr := asReader(r)
  80         f := sniff(rr)
  81         if f.decode == nil {
  82                 return nil, "", ErrFormat
  83         }
  84         m, err := f.decode(rr)
  85         return m, f.name, err
  86 }
  87
  88 // DecodeConfig decodes the color model and dimensions of an image that has
  89 // been encoded in a registered format. The string returned is the format name
  90 // used during format registration. Format registration is typically done by
  91 // an init function in the codec-specific package.
  92 func DecodeConfig(r io.Reader) (Config, string, error) {
  93         rr := asReader(r)
  94         f := sniff(rr)
  95         if f.decodeConfig == nil {
  96                 return Config{}, "", ErrFormat
  97         }
  98         c, err := f.decodeConfig(rr)
  99         return c, f.name, err
 100 }