Subversion Repositories openrisc

// Copyright 2010 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 image

import (
        "bufio"
        "errors"
        "io"
)

// ErrFormat indicates that decoding encountered an unknown format.
var ErrFormat = errors.New("image: unknown format")

// A format holds an image format's name, magic header and how to decode it.
type format struct {
        name, magic  string
        decode       func(io.Reader) (Image, error)
        decodeConfig func(io.Reader) (Config, error)
}

// Formats is the list of registered formats.
var formats []format

// RegisterFormat registers an image format for use by Decode.
// Name is the name of the format, like "jpeg" or "png".
// Magic is the magic prefix that identifies the format's encoding. The magic
// string can contain "?" wildcards that each match any one byte.
// Decode is the function that decodes the encoded image.
// DecodeConfig is the function that decodes just its configuration.
func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error)) {
        formats = append(formats, format{name, magic, decode, decodeConfig})
}

// A reader is an io.Reader that can also peek ahead.
type reader interface {
        io.Reader
        Peek(int) ([]byte, error)
}

// AsReader converts an io.Reader to a reader.
func asReader(r io.Reader) reader {
        if rr, ok := r.(reader); ok {
                return rr
        }
        return bufio.NewReader(r)
}

// Match returns whether magic matches b. Magic may contain "?" wildcards.
func match(magic string, b []byte) bool {
        if len(magic) != len(b) {
                return false
        }
        for i, c := range b {
                if magic[i] != c && magic[i] != '?' {
                        return false
                }
        }
        return true
}

// Sniff determines the format of r's data.
func sniff(r reader) format {
        for _, f := range formats {
                b, err := r.Peek(len(f.magic))
                if err == nil && match(f.magic, b) {
                        return f
                }
        }
        return format{}
}

// Decode decodes an image that has been encoded in a registered format.
// The string returned is the format name used during format registration.
// Format registration is typically done by the init method of the codec-
// specific package.
func Decode(r io.Reader) (Image, string, error) {
        rr := asReader(r)
        f := sniff(rr)
        if f.decode == nil {
                return nil, "", ErrFormat
        }
        m, err := f.decode(rr)
        return m, f.name, err
}

// DecodeConfig decodes the color model and dimensions of an image that has
// been encoded in a registered format. The string returned is the format name
// used during format registration. Format registration is typically done by
// the init method of the codec-specific package.
func DecodeConfig(r io.Reader) (Config, string, error) {
        rr := asReader(r)
        f := sniff(rr)
        if f.decodeConfig == nil {
                return Config{}, "", ErrFormat
        }
        c, err := f.decodeConfig(rr)
        return c, f.name, err
}