Add Hq{2,3,4}x (#624)

* Scaling works on native

* It works in wasm

* Integrate with UI

* Remove benchmark

* Integrate Hqx into Resizer module

* Link against repo for hqx

* Remove unused defaultOpts

* Re-add test file

* Adding size dropdown

* Chrome: go and sit on the naughty step

* Better docs

* Review

* Add link to crbug

* Update src/codecs/processor-worker/index.ts

Co-Authored-By: Jake Archibald <jaffathecake@gmail.com>

* Terminate worker inbetween resize jobs

src/codecs/hqx/processor-meta.ts

@@ -0,0 +1,3 @@
+export interface HqxOptions {
+  factor: 2 | 3 | 4;
+}

src/codecs/hqx/processor.ts

@@ -0,0 +1,32 @@
+import wasmUrl from '../../../codecs/hqx/pkg/squooshhqx_bg.wasm';
+import '../../../codecs/hqx/pkg/squooshhqx';
+import { HqxOptions } from './processor-meta';
+
+interface WasmBindgenExports {
+  resize: typeof import('../../../codecs/hqx/pkg/squooshhqx').resize;
+}
+
+type WasmBindgen = ((url: string) => Promise<void>) & WasmBindgenExports;
+
+declare var wasm_bindgen: WasmBindgen;
+
+const ready = wasm_bindgen(wasmUrl);
+
+export async function hqx(
+  data: ImageData,
+  opts: HqxOptions,
+): Promise<ImageData> {
+  const input = data;
+  await ready;
+  const result = wasm_bindgen.resize(
+    new Uint32Array(input.data.buffer),
+    input.width,
+    input.height,
+    opts.factor,
+  );
+  return new ImageData(
+    new Uint8ClampedArray(result.buffer),
+    data.width * opts.factor,
+    data.height * opts.factor,
+  );
+}

src/codecs/processor-worker/index.ts

@@ -1,4 +1,6 @@
 import { expose } from 'comlink';
+import { isHqx } from '../resize/processor-meta';
+import { clamp } from '../util';
 
 async function mozjpegEncode(
   data: ImageData, options: import('../mozjpeg/encoder-meta').EncodeOptions,
@@ -31,6 +33,18 @@ async function rotate(
 async function resize(
   data: ImageData, opts: import('../resize/processor-meta').WorkerResizeOptions,
 ): Promise<ImageData> {
+  if (isHqx(opts)) {
+    const { hqx } = await import(
+      /* webpackChunkName: "process-hqx" */
+      '../hqx/processor');
+
+    const widthRatio = opts.width / data.width;
+    const heightRatio = opts.height / data.height;
+    const ratio = Math.max(widthRatio, heightRatio);
+    if (ratio <= 1) return data;
+    const factor = clamp(Math.ceil(ratio), { min: 2, max: 4 }) as 2|3|4;
+    return hqx(data, { factor });
+  }
   const { resize } = await import(
     /* webpackChunkName: "process-resize" */
     '../resize/processor');
@@ -63,7 +77,15 @@ async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
   return decode(data);
 }
 
-const exports = { mozjpegEncode, quantize, rotate, resize, optiPngEncode, webpEncode, webpDecode };
+const exports = {
+  mozjpegEncode,
+  quantize,
+  rotate,
+  resize,
+  optiPngEncode,
+  webpEncode,
+  webpDecode,
+};
 export type ProcessorWorkerApi = typeof exports;
 
 expose(exports, self);

src/codecs/processor.ts

@@ -16,6 +16,7 @@ import * as browserGIF from './browser-gif/encoder';
 import * as browserTIFF from './browser-tiff/encoder';
 import * as browserJP2 from './browser-jp2/encoder';
 import * as browserPDF from './browser-pdf/encoder';
+import { bind } from '../lib/initial-util';
 
 type ProcessorWorkerApi = import('./processor-worker').ProcessorWorkerApi;
 
@@ -94,14 +95,7 @@ export default class Processor {
     if (!this._worker) return;
 
     // If the worker is unused for 10 seconds, remove it to save memory.
-    this._workerTimeoutId = self.setTimeout(
-      () => {
-        if (!this._worker) return;
-        this._worker.terminate();
-        this._worker = undefined;
-      },
-      workerTimeout,
-    );
+    this._workerTimeoutId = self.setTimeout(this.terminateWorker, workerTimeout);
   }
 
   /** Abort the current job, if any */
@@ -111,7 +105,11 @@ export default class Processor {
     this._abortRejector(new DOMException('Aborted', 'AbortError'));
     this._abortRejector = undefined;
     this._busy = false;
+    this.terminateWorker();
+  }
 
+  @bind
+  terminateWorker() {
     if (!this._worker) return;
     this._worker.terminate();
     this._worker = undefined;

src/codecs/resize/options.tsx

@@ -12,8 +12,9 @@ import Select from '../../components/select';
 
 interface Props {
   isVector: Boolean;
+  inputWidth: number;
+  inputHeight: number;
   options: ResizeOptions;
-  aspect: number;
   onChange(newOptions: ResizeOptions): void;
 }
 
@@ -21,12 +22,34 @@ interface State {
   maintainAspect: boolean;
 }
 
+const sizePresets = [0.25, 0.3333, 0.5, 1, 2, 3, 4];
+
+/**
+ * Should we allow the user to select hqx? Chrome currently has a wasm bug, so we currently avoid it
+ * there, unless overridden.
+ * crbug.com/974804
+ */
+const allowHqx: boolean = (() => {
+  const url = new URL(location.href);
+  return url.searchParams.has('allow-hqx')
+    // Yep. UA sniffing. Let's hope we can remove this soon.
+    // Block browsers with Chrome/, unless they also have Edge/ (since the Edge UA includes Chrome/)
+    || !navigator.userAgent.includes('Chrome/') || navigator.userAgent.includes('Edge/');
+})();
+
 export default class ResizerOptions extends Component<Props, State> {
   state: State = {
     maintainAspect: true,
   };
 
-  form?: HTMLFormElement;
+  private form?: HTMLFormElement;
+  private presetWidths: { [idx: number]: number } = {};
+  private presetHeights: { [idx: number]: number } = {};
+
+  constructor(props: Props) {
+    super(props);
+    this.generatePresetValues(props.inputWidth, props.inputHeight);
+  }
 
   private reportOptions() {
     const form = this.form!;
@@ -53,18 +76,31 @@ export default class ResizerOptions extends Component<Props, State> {
     this.reportOptions();
   }
 
+  private getAspect() {
+    return this.props.inputWidth / this.props.inputHeight;
+  }
+
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (!prevState.maintainAspect && this.state.maintainAspect) {
-      this.form!.height.value = Math.round(Number(this.form!.width.value) / this.props.aspect);
+      this.form!.height.value = Math.round(Number(this.form!.width.value) / this.getAspect());
       this.reportOptions();
     }
   }
 
+  componentWillReceiveProps(nextProps: Props) {
+    if (
+      this.props.inputWidth !== nextProps.inputWidth ||
+      this.props.inputHeight !== nextProps.inputHeight
+    ) {
+      this.generatePresetValues(nextProps.inputWidth, nextProps.inputHeight);
+    }
+  }
+
   @bind
   private onWidthInput() {
     if (this.state.maintainAspect) {
       const width = inputFieldValueAsNumber(this.form!.width);
-      this.form!.height.value = Math.round(width / this.props.aspect);
+      this.form!.height.value = Math.round(width / this.getAspect());
     }
 
     this.reportOptions();
@@ -74,12 +110,44 @@ export default class ResizerOptions extends Component<Props, State> {
   private onHeightInput() {
     if (this.state.maintainAspect) {
       const height = inputFieldValueAsNumber(this.form!.height);
-      this.form!.width.value = Math.round(height * this.props.aspect);
+      this.form!.width.value = Math.round(height * this.getAspect());
     }
 
     this.reportOptions();
   }
 
+  private generatePresetValues(width: number, height: number) {
+    for (const preset of sizePresets) {
+      this.presetWidths[preset] = Math.round(width * preset);
+      this.presetHeights[preset] = Math.round(height * preset);
+    }
+  }
+
+  private getPreset(): number | string {
+    const { width, height } = this.props.options;
+
+    for (const preset of sizePresets) {
+      if (
+        width === this.presetWidths[preset] &&
+        height === this.presetHeights[preset]
+      ) return preset;
+    }
+
+    return 'custom';
+  }
+
+  @bind
+  private onPresetChange(event: Event) {
+    const select = event.target as HTMLSelectElement;
+    if (select.value === 'custom') return;
+    const multiplier = Number(select.value);
+    (this.form!.width as HTMLInputElement).value =
+      Math.round(this.props.inputWidth * multiplier) + '';
+    (this.form!.height as HTMLInputElement).value =
+      Math.round(this.props.inputHeight * multiplier) + '';
+    this.reportOptions();
+  }
+
   render({ options, isVector }: Props, { maintainAspect }: State) {
     return (
       <form ref={linkRef(this, 'form')} class={style.optionsSection} onSubmit={preventDefault}>
@@ -95,12 +163,22 @@ export default class ResizerOptions extends Component<Props, State> {
             <option value="mitchell">Mitchell</option>
             <option value="catrom">Catmull-Rom</option>
             <option value="triangle">Triangle (bilinear)</option>
+            {allowHqx && <option value="hqx">hqx (pixel art)</option>}
             <option value="browser-pixelated">Browser pixelated</option>
             <option value="browser-low">Browser low quality</option>
             <option value="browser-medium">Browser medium quality</option>
             <option value="browser-high">Browser high quality</option>
           </Select>
         </label>
+        <label class={style.optionTextFirst}>
+          Preset:
+          <Select value={this.getPreset()} onChange={this.onPresetChange}>
+            {sizePresets.map(preset =>
+              <option value={preset}>{preset * 100}%</option>,
+            )}
+            <option value="custom">Custom</option>
+          </Select>
+        </label>
         <label class={style.optionTextFirst}>
           Width:
           <input

src/codecs/resize/processor-meta.ts

@@ -1,8 +1,26 @@
-type BrowserResizeMethods = 'browser-pixelated' | 'browser-low' | 'browser-medium' | 'browser-high';
-type WorkerResizeMethods = 'triangle' | 'catrom' | 'mitchell' | 'lanczos3';
-const workerResizeMethods: WorkerResizeMethods[] = ['triangle', 'catrom', 'mitchell', 'lanczos3'];
+type BrowserResizeMethods =
+  | 'browser-pixelated'
+  | 'browser-low'
+  | 'browser-medium'
+  | 'browser-high';
+type WorkerResizeMethods =
+  | 'triangle'
+  | 'catrom'
+  | 'mitchell'
+  | 'lanczos3'
+  | 'hqx';
+const workerResizeMethods: WorkerResizeMethods[] = [
+  'triangle',
+  'catrom',
+  'mitchell',
+  'lanczos3',
+  'hqx',
+];
 
-export type ResizeOptions = BrowserResizeOptions | WorkerResizeOptions | VectorResizeOptions;
+export type ResizeOptions =
+  | BrowserResizeOptions
+  | WorkerResizeOptions
+  | VectorResizeOptions;
 
 export interface ResizeOptionsCommon {
   width: number;
@@ -29,10 +47,21 @@ export interface VectorResizeOptions extends ResizeOptionsCommon {
  *
  * @param opts
  */
-export function isWorkerOptions(opts: ResizeOptions): opts is WorkerResizeOptions {
+export function isWorkerOptions(
+  opts: ResizeOptions,
+): opts is WorkerResizeOptions {
   return (workerResizeMethods as string[]).includes(opts.method);
 }
 
+/**
+ * Return whether a set of options are from the HQ<n>X set
+ *
+ * @param opts
+ */
+export function isHqx(opts: ResizeOptions): opts is WorkerResizeOptions {
+  return opts.method === 'hqx';
+}
+
 export const defaultOptions: ResizeOptions = {
   // Width and height will always default to the image size.
   // This is set elsewhere.

src/codecs/util.ts

@@ -25,3 +25,12 @@ export function initEmscriptenModule<T extends EmscriptenWasm.Module>(
     });
   });
 }
+
+interface ClampOpts {
+  min?: number;
+  max?: number;
+}
+
+export function clamp(x: number, opts: ClampOpts): number {
+  return Math.min(Math.max(x, opts.min || Number.MIN_VALUE), opts.max || Number.MAX_VALUE);
+}