gif

README

image/gif

A modified image/gif package from the go standard library (originally by Andy). The change is to allow streaming gif to a file or to any io.writer.

Example usage

e := gif.NewStreamEncoder(someFile, &StreamEncoderOptions{ })
for recording {
    image := takeScreenShot()
    delay := 1
    if err := e.Encode(image, delay, gif.DisposalNone); err != nil {
        handleError(err)
    }
}

if err := e.Close(); err != nil {
    handleError(err)
}

Documentation

Overview

Package gif implements a GIF image decoder and encoder.

The GIF specification is at https://www.w3.org/Graphics/GIF/spec-gif89a.txt.

Index

• Constants
• func Decode(r io.Reader) (image.Image, error)
• func DecodeConfig(r io.Reader) (image.Config, error)
• func Encode(w io.Writer, m image.Image, o *Options) error
• func EncodeAll(w io.Writer, g *GIF) error
• type GIF
  • func DecodeAll(r io.Reader) (*GIF, error)
• type Options
• type StreamEncoder
  • func NewStreamEncoder(w io.Writer, options *StreamEncoderOptions) *StreamEncoder
  • func (e *StreamEncoder) Close() error
  • func (e *StreamEncoder) Encode(pm *image.Paletted, delay int, disposal uint8) error
• type StreamEncoderOptions

Constants

const (
	DisposalNone       = 0x01
	DisposalBackground = 0x02
	DisposalPrevious   = 0x03
)

Disposal Methods.

Functions

func Decode

func Decode(r io.Reader) (image.Image, error)

Decode reads a GIF image from r and returns the first embedded image as an image.Image.

func DecodeConfig

func DecodeConfig(r io.Reader) (image.Config, error)

DecodeConfig returns the global color model and dimensions of a GIF image without decoding the entire image.

func Encode

func Encode(w io.Writer, m image.Image, o *Options) error

Encode writes the Image m to w in GIF format.

func EncodeAll

func EncodeAll(w io.Writer, g *GIF) error

EncodeAll writes the images in g to w in GIF format with the given loop count and delay between frames.

Types

type GIF

type GIF struct {
	Image []*image.Paletted // The successive images.
	Delay []int             // The successive delay times, one per frame, in 100ths of a second.
	// LoopCount controls the number of times an animation will be
	// restarted during display.
	// A LoopCount of 0 means to loop forever.
	// A LoopCount of -1 means to show each frame only once.
	// Otherwise, the animation is looped LoopCount+1 times.
	LoopCount int
	// Disposal is the successive disposal methods, one per frame. For
	// backwards compatibility, a nil Disposal is valid to pass to EncodeAll,
	// and implies that each frame's disposal method is 0 (no disposal
	// specified).
	Disposal []byte
	// Config is the global color table (palette), width and height. A nil or
	// empty-color.Palette Config.ColorModel means that each frame has its own
	// color table and there is no global color table. Each frame's bounds must
	// be within the rectangle defined by the two points (0, 0) and
	// (Config.Width, Config.Height).
	//
	// For backwards compatibility, a zero-valued Config is valid to pass to
	// EncodeAll, and implies that the overall GIF's width and height equals
	// the first frame's bounds' Rectangle.Max point.
	Config image.Config
	// BackgroundIndex is the background index in the global color table, for
	// use with the DisposalBackground disposal method.
	BackgroundIndex byte
}

GIF represents the possibly multiple images stored in a GIF file.

func DecodeAll

func DecodeAll(r io.Reader) (*GIF, error)

DecodeAll reads a GIF image from r and returns the sequential frames and timing information.

type Options

type Options struct {
	// NumColors is the maximum number of colors used in the image.
	// It ranges from 1 to 256.
	NumColors int

	// Quantizer is used to produce a palette with size NumColors.
	// palette.Plan9 is used in place of a nil Quantizer.
	Quantizer draw.Quantizer

	// Drawer is used to convert the source image to the desired palette.
	// draw.FloydSteinberg is used in place of a nil Drawer.
	Drawer draw.Drawer
}

Options are the encoding parameters.

type StreamEncoder

type StreamEncoder struct {
	// contains filtered or unexported fields
}

StreamEncoder allows encoding and writing images to w one at a time without accumulating an array of images. Use this to reduce memory consumption.

func NewStreamEncoder

func NewStreamEncoder(w io.Writer, options *StreamEncoderOptions) *StreamEncoder

Creates a streamer.

func (*StreamEncoder) Close

func (e *StreamEncoder) Close() error

Closes the streamer, which finalizes the write to w. Returns an error if streamer.Encode() is not called at least once, or if config is invalid. Note: not concurrent-safe

func (*StreamEncoder) Encode

func (e *StreamEncoder) Encode(pm *image.Paletted, delay int, disposal uint8) error

Encode writes the Image m to w in GIF format. Note: not concurrent-safe

type StreamEncoderOptions

type StreamEncoderOptions struct {
	// LoopCount controls the number of times an animation will be
	// restarted during display.
	// A LoopCount of 0 means to loop forever.
	// A LoopCount of -1 means to show each frame only once.
	// Otherwise, the animation is looped LoopCount+1 times.
	LoopCount int

	// Config is the global color table (palette), width and height. A nil or
	// empty-color.Palette Config.ColorModel means that each frame has its own
	// color table and there is no global color table. Each frame's bounds must
	// be within the rectangle defined by the two points (0, 0) and
	// (Config.Width, Config.Height).
	//
	// For backwards compatibility, a zero-valued Config is valid to pass to
	// EncodeAll, and implies that the overall GIF's width and height equals
	// the first frame's bounds' Rectangle.Max point.
	Config image.Config

	// BackgroundIndex is the background index in the global color table, for
	// use with the DisposalBackground disposal method.
	BackgroundIndex byte
}