webp

Use cwebp using functions for V.

Summary

• About
• Features
• Requirements
• Installation
• Examples
• Available options
• Test

About

I created this library to convert my images into smaller webp version, to save my end-user bandwidth when their browser supports this format.

For the record, this library is shipped with a test image, at misc/fruits.png . Converting it without any options led to a file size reduction of 81% (from 462 KB to 25 KB)

Features

• Supports all the cwebp options
• Use the cwebp executable

Requirements

• cwebp executable on your machine (the required packages are - often called - libwebp and libwebp-tools on Linux based OS)

Installation

v install khalyomede.webp

Examples

• 1. JPG to WebP conversion
• 2. Get the command output
• 3. Get the version of the executable

1. JPG to WebP conversion

In this example, we will convert a .jpg file to .webp.

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
  }) or {
    panic(err)
  }
}

2. Get the command output

In this example, we will not execute the command but rather get its output. Useful if you want to debug it.

import khalyomede.webp { Options }

fn main() {
  cmd := webp.command(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
  })

  assert cmd == "cwebp -o fruits.webp fruits.jpg"
}

3. Get the version of the executable

In this example, we will get the version of the cwebp executable.

import khalyomede.webp

fn main() {
  version := webp.version()

  assert version == "1.1.0"
}

Available options

• -lossless
• -near_lossless
• -q
• -z
• -alpha_q
• -preset
• -m
• -resize
• -crop
• -mt
• -low_memory
• -size
• -psnr
• -pass
• -af
• -jpeg_like
• -f
• -sharpness
• -nostrong
• -sharp_yuv
• -sns
• -segments
• -partition_limit
• -pre
• -alpha_filter
• -alpha_method
• -exact
• -blend_alpha
• -noalpha
• -hint
• -metadata
• -noasm

lossless

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    lossless: true,
  }) or {
    panic(err)
  }
}

-near_lossless

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    near_lossless: 60,
  }) or {
    panic(err)
  }
}

-q

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    quality: 75,
  }) or {
    panic(err)
  }
}

-z

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    compression_mode: 6,
  }) or {
    panic(err)
  }
}

-alpha_q

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    alpha_quality: 80,
  }) or {
    panic(err)
  }
}

-preset

import khalyomede.webp { Options, Preset }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    preset: Preset.photo,
  }) or {
    panic(err)
  }
}

-m

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    compression_method: 4,
  }) or {
    panic(err)
  }
}

-resize

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    resize: {
      width: 600,
      height: 800
    },
  }) or {
    panic(err)
  }
}

-crop

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    crop: {
      x_position: 0,
      y_position: 100,
      width: 600,
      height: 800
    },
  }) or {
    panic(err)
  }
}

-mt

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    multi_threading: true,
  }) or {
    panic(err)
  }
}

-low_memory

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    low_memory: true,
  }) or {
    panic(err)
  }
}

-size

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    size: 24000,
  }) or {
    panic(err)
  }
}

-psnr

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    psnr: 11,
  }) or {
    panic(err)
  }
}

-pass

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    pass: 6,
  }) or {
    panic(err)
  }
}

-af

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    auto_filter: true,
  }) or {
    panic(err)
  }
}

-jpeg_like

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    jpeg_like: true,
  }) or {
    panic(err)
  }
}

-f

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    deblocking_filter_strength: 20,
  }) or {
    panic(err)
  }
}

-sharpness

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    sharpness: 4,
  }) or {
    panic(err)
  }
}

-nostrong

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    nostrong: true,
  }) or {
    panic(err)
  }
}

-sharp_yuv

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    sharp_yuv: true,
  }) or {
    panic(err)
  }
}

-sns

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    spatial_noise_shaping: 50,
  }) or {
    panic(err)
  }
}

-segments

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    segments: 3,
  }) or {
    panic(err)
  }
}

-partition_limit

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    partition_limit: 50,
  }) or {
    panic(err)
  }
}

-pre

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    pre_processing: 2,
  }) or {
    panic(err)
  }
}

-alpha_filter

import khalyomede.webp { Options, AlphaFilter }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    alpha_filter: AlphaFilter.best,
  }) or {
    panic(err)
  }
}

-alpha_method

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    alpha_method: 0,
  }) or {
    panic(err)
  }
}

-exact

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    exact: true,
  }) or {
    panic(err)
  }
}

-blend_alpha

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    blend_alpha: 40,
  }) or {
    panic(err)
  }
}

-noalpha

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    noalpha: true,
  }) or {
    panic(err)
  }
}

-hint

import khalyomede.webp { Options, Hint }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    hint: Hint.picture,
  }) or {
    panic(err)
  }
}

-metadata

import khalyomede.webp { Options, Metadata }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    metadata: Metadata.exif,
  }) or {
    panic(err)
  }
}

-noasm

import khalyomede.webp { Options }

fn main() {
  webp.exec(Options{
    input: "fruits.jpg",
    output: "fruits.webp",
    noasm: true,
  }) or {
    panic(err)
  }
}

Test

v test .