@swf2es/native 0.1.14 → 0.1.16

package/README.md

@@ -7,12 +7,14 @@ swf2es's WebAssembly modules, built with the repository's pinned Zig:
   tessellation (`Tessellator`), a shape layer's lines built in one call
   (`LineBuilder`), BitmapData's filters and pixel operations (`BitmapKernel`),
   and whole-level DXT1/DXT5 texture encoding (`DxtEncoder`).
-- `@swf2es/native/compress`: synchronous zlib and LZMA.
+- `@swf2es/native/compress`: synchronous zlib and LZMA, and the PNG and
+  JPEG encoders' passes over a bitmap.
 - `@swf2es/native/mp3`: synchronous MP3 frame decoding with minimp3.
 - `@swf2es/native/audio`: synchronous ADPCM and Nellymoser decoding, in
   Zig alone.
 - `@swf2es/native/atf`: Stage3D's ATF textures, read and decoded to what a
-  desktop GPU takes, their JPEG XR images by jxrlib.
+  desktop GPU takes, their JPEG XR images by jxrlib; and JPEG XR files
+  written as Flash's `BitmapData.encode` writes them, by jxrlib's encoder.
 
 The package depends on no other package and uses no DOM or node APIs.
 `compress`, `mp3`, `audio` and `atf` each compile their own module. What the renderer
@@ -239,6 +241,13 @@ Upstream sources stay unchanged.
   alpha; with `filter`, given the filter of PNG's five whose output sums
   smallest, libpng's heuristic, sixteen bytes at a time (Wasm SIMD); and
   handed to the deflate.
+- `jpegEncode(pixels, width, height, quality)` makes a JPEG file of a
+  bitmap's ARGB pixels, alpha left out, as Flash's encoder does
+  (`jpeg.zig`, Zig alone): JFIF, 4:2:0, Annex K's quantization tables
+  scaled to the quality as the IJG scales them and its Huffman tables.
+  Colours are converted eight pixels at a time and the DCTs run eight and
+  sixteen columns at a time (Wasm SIMD); a chroma block is the low half
+  of its MCU's 16 by 16 DCT, as libjpeg scales since version 7.
 - `lzmaDecode(stream, size)` decodes an LZMA stream, its 5 property bytes
   first, to `size` bytes or to its end marker.
 - `lzmaEncode(data)` writes `ByteArray`'s LZMA: properties, an 8-byte
@@ -487,10 +496,11 @@ skips (PVRTC's, ETC's), leaves that level and those after it absent, as
 does a level whose blocks for the desktop are empty (png2atf's `-n`).
 Nothing of the reserved bytes is read.
 
-jxrlib's decoder and glue (`vendor/jxrlib`, https://github.com/swf2es/jxrlib,
+jxrlib's decoder, glue and encoder (`vendor/jxrlib`, https://github.com/swf2es/jxrlib,
 a fork of 4creators/jxrlib, Microsoft's release, at tag `v2019.10.9`) are
-compiled unchanged, without its encoder, at `-Os`: the module is about
-100 KB, against 150 KB at `-O2` for 3% less time. `src/atf/jxr.c` decodes
+compiled unchanged at `-Os` (the encoder without `strenc_x86.c`, SSE2's):
+the module is about 154 KB, 101 KB of it the decoder's (150 KB at `-O2`
+for 3% less decoding time), and 56 KB gzipped. `src/atf/jxr.c` decodes
 an image in the pixel format its block must have, setting jxrlib's output
 to the container's pixel format as jxrlib's own decoder does (the
 codestream may name another, which jxrlib would write by into a buffer
@@ -502,6 +512,18 @@ its allocator over a bump arena that each call resets. The instance is
 kept between images as compress's is (`src/instance.ts`, the same
 `MEMORY_KEPT`).
 
+`jxrEncode(pixels, width, height, { alpha, quantization, subsampling,
+trimFlexBits })` writes the JPEG XR file Flash's `BitmapData.encode`
+writes for the same pixels, byte for byte (docs/architecture/bitmaps.md
+has what Flash chooses). jxrlib's encoder writes the codestream, its rows
+copied in 16 at a time; `jxr.c` then rewrites its headers as Flash's
+(one quantizer index for all channels, the size always in 16 bits), pads
+it as Flash does and wraps it in Flash's container of five tags. The
+output grows in place at the top of the arena, so a file costs its own
+size and the encoder's few rows of macroblocks. A 4800 by 2475 picture
+encodes in about 150 ms at Flash's default quantization, 20, and 235 ms
+lossless (`jpegEncode` takes 70 at quality 80); with alpha, 205 ms.
+
 jxrlib is not memory safe on corrupt input: AddressSanitizer finds it
 reading past its tables and writing through null pointers. In the module
 these stay within its memory, whose stack comes first: a null pointer's