webp

type ARGBImg struct {
	// Pix holds the image's pixels, store A,R,G,B from hi to lo in uint32
	Pix []uint32
	// Stride is the Pix stride in pixels units, not bytes between vertically adjacent pixels.
	Stride int
	// Rect is the image's bounds.
	Rect image.Rectangle
}

type AlphaFilter int

type BitStreamFormat int

type BitstreamFeatures struct {
	Width, Height int
	Format        BitStreamFormat
	HasAlpha      bool
	HasAnimation  bool
}

type DecCspMode int

type DecPixelFormat func(config *C.WebPDecoderConfig, w, h int) image.Image

type DecodeOptions struct {
	BypassFiltering        bool            // if true, skip the in-loop filtering
	NoFancyUpsampling      bool            // if true, use faster pointwise upsampler
	Crop                   image.Rectangle // do cropping if not empty, this is applied _first_
	Scale                  image.Rectangle // do scaling if not empty,  this is applied _afterward_
	UseThreads             bool            // if true, use multi-threaded decoding
	DitheringStrength      int             // dithering strength (0=Off, 100=full)
	Flip                   bool            // flip output vertically
	AlphaDitheringStrength int             // alpha dithering strength in [0..100]
	ImageType              DecPixelFormat  // decoded image type
}

type EncodeOptions struct {
	Lossless bool
	// between 0 and 100. For lossy, 0 gives the smallest
	// size and 100 the largest. For lossless, this
	// parameter is the amount of effort put into the
	// compression: 0 is the fastest but gives larger
	// files compared to the slowest, but best, 100.
	Quality float32
	// quality/speed trade-off (0=fast, 6=slower-better)
	Method int
	// Hint for image type (lossless only for now)
	ImageHint ImageHint
	// if non-zero, set the desired target size in bytes. Takes precedence over the 'compression' parameter.
	TargetSize int
	// if non-zero, specifies the minimal distortion to try to achieve. Takes precedence over target_size
	TargetPSNR float32
	// maximum number of segments to use, in [1..4]
	Segments int
	// Spatial Noise Shaping. 0=off, 100=maximum
	SnsStrength int
	// range: [0 = off .. 100 = strongest]
	FilterStrength int
	// range: [0 = off .. 7 = least sharp]
	FilterSharpness int
	// filtering type: 0 = simple, 1 = strong (only used if filter_strength > 0 or autofilter > 0)
	FilterType FilterType
	// Auto adjust filter's strength
	AutoFilter bool
	// Algorithm for encoding the alpha plane (0 = none, 1 = compressed with WebP lossless). Default is 1
	AlphaCompression int
	// Predictive filtering method for alpha plane. 0: none, 1: fast, 2: best. Default if 1.
	AlphaFiltering AlphaFilter
	// Between 0 (smallest size) and 100 (lossless). Default is 100.
	AlphaQuality int
	// number of entropy-analysis passes (in [1..10]).
	Pass int
	// if true, export the compressed picture back. In-loop filtering is not applied.
	ShowCompressed bool
	// preprocessing filter: 0=none, 1=segment-smooth, 2=pseudo-random dithering
	Preprocessing int
	// log2(number of token partitions) in [0..3]. Default is set to 0 for easier progressive decoding.
	Partitions int
	// quality degradation allowed to fit the 512k limit on prediction modes coding (0: no degradation, 100: maximum possible degradation).
	PartitionLimit int
	// If true, compression parameters will be remapped
	// to better match the expected output size from
	// JPEG compression. Generally, the output size will
	// be similar but the degradation will be lower.
	EmulateJpegSize bool
	// If true, try and use multi-threaded encoding.
	ThreadLevel bool
	// If set, reduce memory usage (but increase CPU use).
	LowMemory bool
	// Near lossless encoding [0 = max loss .. 100 = off
	// (default)].
	NearLossless int
	// if true, preserve the exact RGB values under
	// transparent area. Otherwise, discard this invisible
	// RGB information for better compression. The default
	// value is 0.
	Exact bool
	// reserved for future lossless feature
	UseDeltaPalette int
	// if needed, use sharp (and slow) RGB->YUV conversion
	UseSharpYUV bool
}

type EncodePreset int

type FilterType int

type FourCC [4]byte

type ImageHint int

type MuxError int

type NYCbCrA struct {
	image.NYCbCrA
}

type RGBImg struct {
	// Pix holds the image's pixels, in R, G, B order.
	Pix []uint8
	// Stride is the Pix stride (in bytes) between vertically adjacent pixels.
	Stride int
	// Rect is the image's bounds.
	Rect image.Rectangle
}

type VP8DecodeError string

type VP8EncodeError int

type VP8StatusCode int

type Version int

type YCbCr struct {
	image.YCbCr
}