mingyuetutu0527's picture
Add benchmark dataset, method and dataset card
efb887d verified
|
Raw History Blame Contribute Delete
4.85 kB

Method

Every number in data/browser-encoder-benchmarks.csv was produced by running tools/bench.html in headless Chrome on one machine. Nothing in the CSV is estimated, copied from another site, or extrapolated from a formula.

Environment

Item Value
Browser Chrome 156.0.8078.80 (headless)
OS Windows 11 Pro, x64
Encoders canvas.toBlob() — the browser's own JPEG and WebP encoders
Run date 2026-11-03
Harness tools/bench.html, driven by tools/run-headless.js over the DevTools protocol

What is measured

For each combination of source pattern, source resolution, output format and target size, the harness records the blob the encoder actually returns: its byte size, the quality setting it settled on, and the downscale factor applied to the pixels.

Matrix: 3 patterns × 3 resolutions × 2 formats × 6 targets = 108 runs.

  • Patterns: photo, screenshot, flat
  • Resolutions: 4000×3000, 1920×1080, 1024×1024
  • Formats: image/jpeg, image/webp
  • Targets: 20, 50, 100, 200, 500, 1024 KB (1 KB = 1024 bytes here)

How the test images are generated

No stock photos are shipped with this repo. Each source image is drawn on a canvas from a seeded linear congruential generator, so the same pattern at the same resolution is byte-identical on every machine and every run.

  • photo — a three-stop diagonal gradient, 60 translucent discs, then ±13 levels of per-pixel grain. The grain is the point: it is what makes a photograph expensive to encode, and it is the main reason a photo cannot be squeezed as hard as a screenshot.
  • screenshot — white background, dark word-shaped blocks on a regular baseline grid, 8 coloured rectangles. Sharp edges, flat colour: the opposite case, where the encoder can spend almost nothing.
  • flat — a near-solid two-stop vertical gradient. The floor case: what a target size looks like when the content is trivially compressible.

These are synthetic. They are reproducible and they bracket the range, but they are not your photos. See the caveats below.

The search

Same policy the site uses, reimplemented in tools/hit-target-size.js:

  1. Hold the pixel dimensions. Binary-search quality in [0.40, 0.95], 7 steps.
  2. If quality 0.40 at full resolution still overshoots the target, binary-search the downscale factor in [0.05, 1.0] at quality 0.40, 7 steps.
  3. At the largest scale that fits, spend the leftover budget on quality: another 7-step binary search in [0.40, 0.95] at that scale.
  4. If nothing fits, the row is recorded with fits=0 and the smallest attempt.

7 steps over a 0.55-wide range resolves quality to about 0.4%, finer than the encoder's own quantisation, at a cost of up to 21 full encodes per cell.

One artifact worth knowing about

Downscaling is not a gentle dial. drawImage resamples every pixel, which destroys high-frequency detail — and high-frequency detail is exactly what costs bytes. On the grain-heavy photo source a 0.4% reduction in scale cut the WebP blob from 611,160 bytes to 156,668 bytes in a single step. That is a real measurement, not a bug, and it is why the rows in this dataset are not a smooth function of scale: a small downscale can free up far more budget than the pixel count suggests.

Caveats — read these before quoting a row

  • Synthetic sources, not photographs. A real 12 MP camera JPEG has different noise characteristics. Expect real photos to need more aggressive settings than the photo rows here.
  • One browser, one build. Chrome 156's JPEG and WebP encoders. Firefox and Safari use different implementations and will not produce these exact bytes.
  • Encoder output is not monotonic in quality. toBlob() at quality q and q+0.001 can return the same or even a larger blob. The binary search assumes monotonicity as a working approximation; individual rows can therefore land a fraction of a percent under the target rather than exactly on it.
  • Colour management is not exercised. Sources are sRGB canvases. Images carrying an embedded ICC profile are converted by the browser before encoding and can behave differently.
  • image/webp quality in Chrome is not the same scale as JPEG quality. The numbers are comparable within a format, not across formats.

Reproducing

# serve the folder (file:// works too, but a local server is cleaner)
python -m http.server 8000

# open tools/bench.html in Chrome, then from the DevTools console:
await runAll()          # returns the CSV as a string

Or drive it headless:

chrome --headless=new --remote-debugging-port=9444 \
       --user-data-dir=/tmp/bench file:///path/to/tools/bench.html

node tools/run-headless.js 9444 out.csv

Expect 10-20 minutes on a laptop: the 4000×3000 photo cells dominate the run.