webp Go Library

When data is being transmitted progressively, use the incremental decoding API. This uses a WebPIDecoder object to maintain state.

Workflow:

1. Initialize: Create a buffer (WebPDecBuffer) and initialize it with WebPInitDecBuffer. Set the colorspace (e.g., MODE_BGR).
2. Create Decoder: Create the decoder instance with WebPINewDecoder(&buffer).
3. Feed Data: As data arrives, use one of two methods:
   • WebPIAppend(idec, fresh_data, size_of_fresh_data): Appends new bytes.
   • WebPIUpdate(idec, buffer, size_of_transmitted_buffer): Updates the decoder based on the new total size of the buffer.
4. Check Status: Functions return VP8_STATUS_OK (done) or VP8_STATUS_SUSPENDED (more data needed). Any other value is an error.
5. Retrieve Pixels: Use WebPIDecGetRGB or WebPIDecGetYUVA to get the partially decoded pixels.
6. Cleanup: Always call WebPIDelete(idec) to release the decoder.

WebPDecBuffer buffer;
WebPInitDecBuffer(&buffer);
buffer.colorspace = MODE_BGR;
WebPIDecoder* idec = WebPINewDecoder(&buffer);

// As data arrives:
WebPIAppend(idec, fresh_data, size_of_fresh_data);

// Check status:
// VP8_STATUS_OK or VP8_STATUS_SUSPENDED

// Retrieve pixels:
// WebPIDecGetRGB(idec, ...);

WebPIDelete(idec);

The gif2webp utility (located in examples/) converts animated GIF files to WebP animation.

Usage:

gif2webp [options] gif_file -o webp_file

Options:

• -h / -help: Show help
• -lossy: Encode image using lossy compression
• -mixed: Heuristically pick lossy or lossless compression for each frame
• -q <float>: Quality factor (0:small..100:big)
• -m <int>: Compression method (0=fast, 6=slowest)
• -min_size: Minimize output size (default: off; uses lossless by default; can be combined with -q, -m, -lossy, or -mixed)
• -kmin <int>: Min distance between key frames
• -kmax <int>: Max distance between key frames
• -f <int>: Filter strength (0=off..100)
• -metadata <string>: Comma separated list of metadata to copy (valid values: all, none, icc, xmp; default: xmp)
• -loop_compatibility: Use compatibility mode for Chrome versions prior to M62
• -mt: Use multi-threading if available
• -version: Print version number and exit
• -v: Verbose mode
• -quiet: Don't print anything

Building gif2webp: Requires libgif development files. You can build using makefile.unix or autoconf:

# Using makefile.unix
make -f makefile.unix examples/gif2webp

# Using autoconf
./configure --enable-everything
make

Use the cwebp tool to convert images (PNG, JPEG, TIFF, or WebP) into WebP format.

Basic Usage

To convert an input file with a specific quality factor (0-100, where 100 is best):

cwebp input.png -q 80 -o output.webp

Lossless Encoding

To compress the source without any loss, use the -lossless flag. In this mode, the -q parameter controls the amount of processing time spent to minimize file size rather than visual quality.

cwebp input.png -lossless -q 75 -o output.webp

Tuning Visual Quality

For advanced tuning, use these options in combination:

• -preset <string>: Sets a default configuration for specific input types (default, photo, picture, drawing, icon, text). Note: This must come first in the command line.
• -sns <int>: Spatial noise shaping (0-100). Higher values (e.g., 75) improve quality at the cost of larger files by optimizing bit allocation.
• -f <int>: Filter strength (0-100). Higher values result in smoother highly-compressed areas. Typical values are 20-30.
• -m <int>: Compression method (0=fast, 6=slowest). Higher values increase encoding time for better quality.

To cross-compile for MIPS Linux, you must first add your toolchain to your PATH. The build requires specific MIPS_CFLAGS and MIPS_LDFLAGS depending on whether you are targeting 32-bit or 64-bit architectures.

32-bit (mips32r5 / p5600):

• HOST=mips-mti-linux-gnu
• MIPS_CFLAGS="-O3 -mips32r5 -mabi=32 -mtune=p5600 -mmsa -mfp64 -msched-weight -mload-store-pairs -fPIE"
• MIPS_LDFLAGS="-mips32r5 -mabi=32 -mmsa -mfp64 -pie"

64-bit (mips64r6 / i6400):

• HOST=mips-img-linux-gnu
• MIPS_CFLAGS="-O3 -mips64r6 -mabi=64 -mtune=i6400 -mmsa -mfp64 -msched-weight -mload-store-pairs -fPIE"
• MIPS_LDFLAGS="-mips64r6 -mabi=64 -mmsa -mfp64 -pie"

# Example for 32-bit
export PATH=$PATH:/path/to/toolchain/bin
HOST=mips-mti-linux-gnu
MIPS_CFLAGS="-O3 -mips32r5 -mabi=32 -mtune=p5600 -mmsa -mfp64 -msched-weight -mload-store-pairs -fPIE"
MIPS_LDFLAGS="-mips32r5 -mabi=32 -mmsa -mfp64 -pie"

./configure --host=${HOST} --build=`config.guess` \
  CC="${HOST}-gcc -EL" \
  CFLAGS="$MIPS_CFLAGS" \
  LDFLAGS="$MIPS_LDFLAGS"
make
make install

The Advanced Decoding API allows for on-the-fly cropping and rescaling. This is highly efficient for memory-constrained environments because memory usage scales with the output size rather than the input size.

Workflow:

1. Initialize Config: Call WebPInitDecoderConfig(&config).
2. Get Features: (Optional) Use WebPGetFeatures to inspect the bitstream.
3. Configure Options: Set config.options.use_scaling = 1 and provide scaled_width and scaled_height. You can also disable fancy upsampling with no_fancy_upsampling.
4. Configure Output: Specify the output colorspace (e.g., MODE_BGRA) and optionally provide an external buffer via config.output.u.RGBA.rgba to avoid extra allocations.
5. Decode:
   • For full images: WebPDecode(data, data_size, &config).
   • For incremental/small buffer decoding: Use WebPIDecode to get a WebPIDecoder* and feed it with WebPIAppend.
6. Cleanup: Call WebPFreeDecBuffer(&config.output) to reclaim memory.

WebPDecoderConfig config;
WebPInitDecoderConfig(&config);

// Optional: Get features
WebPGetFeatures(data, data_size, &config.input);

// Configure scaling/cropping
config.options.use_scaling = 1;
config.options.scaled_width = 100;
config.options.scaled_height = 100;

// Configure output
config.output.colorspace = MODE_BGRA;
config.output.is_external_memory = 1;
config.output.u.RGBA.rgba = my_buffer;
config.output.u.RGBA.stride = stride;
config.output.u.RGBA.size = size;

// Decode
WebPDecode(data, data_size, &config);

// Cleanup
WebPFreeDecBuffer(&config.output);