open-standards/wai/extensions/format-probes.md

# WAI Extension: Format Probes

> Status: Draft. A **header probe** for each sink-supplied format the registry names whose
> payload WAI does not decode itself: it identifies a payload as the format its capability
> names and reads the parameters the format's headers state, or refuses it with one of the
> codes of §12. No probe decodes a picture or a sound. Probes are defined for JPEG XS
> (`wai.image.jxs`, `wai.video.jxs`), H.265 and MV-HEVC (`wai.video.hevc`,
> `wai.video.mvhevc`), H.266 (`wai.video.vvc`), LCEVC (`wai.video.lcevc`), MPEG-H 3D Audio
> (`wai.audio.mpegh`), AVS3 video and audio (`wai.video.avs3`, `wai.audio.avs3`), the picture
> header of IEEE 1857.11 (`wai.image.ieee1857_11`, a candidate), the projection descriptor
> (`wai.meta.projection`, [projection](projection.md)), AV2 (`wai.video.av2`), AC-4
> (`wai.audio.ac4`), IAMF (`wai.audio.iamf`) and IVAS (`wai.audio.ivas`); §18 says why EVC has
> none, and §19 why the two candidates that code for machines have none. §3.5 maps a JPEG XS payload onto the media-type parameters of RFC 9134 and the
> constant-rate carriage of SMPTE ST 2110-22, and §14 to §17 give the codecs parameter string
> each binding defines (§2.6). The reference implementation is the `format_probe` module of
> `wai-rs` (feature `format_probe`) and its tool `wai_format_probe`; the corpus is
> [`format-probe-conformance/`](../format-probe-conformance/), and its second implementation
> is `format-probe-conformance/format_probe_verify.py`.
> Keywords **MUST**, **MUST NOT**, **SHOULD**, **MAY** are RFC 2119/8174.
>
> Texts read for this revision: ITU-T H.265 (V11, 01/2026) and ITU-T H.266 (V4, 01/2026),
> whole; ITU-T H.273 and ITU-T H.274 (V4, 01/2026) §8.15; RFC 9134; SMPTE ST 2110-22:2022; the
> public previews of ISO/IEC 21122-2:2022/Amd 1:2022 (Tables A.7 and A.16) and ISO/IEC
> 21122-4:2022 (§6.3, Annex B.2); ATSC A/342-3:2024-04 §5.2; ETSI TS 101 154 V2.10.1 §5.16.2 and
> §6.10.2; the AV2 Bitstream & Decoding Process Specification v1.0.0 (28 May 2026) §4 to §7 and
> Annexes A and B, and the AV2 Codec ISO Media File Format Binding as a working draft (10
> November 2026, §6); ETSI TS 103 190-1 V1.4.1 (2025-07) §4.2 and Annexes F and G, and ETSI TS
> 103 190-2 V1.3.1 (2025-07) §4.6, §6.2.1, §6.3.2.1 and Annex E; Immersive Audio Model and
> Formats v2.0.0 (24 August 2026) §3 to §6 and §8; 3GPP TS 26.253 V19.3.0 (2026-06) §5.1 and
> Annex A, TS 26.445 V19.1.0 (2025-12) Annex A.2.2, and TS 26.244 V19.1.0 (2025-12) §6.15 to
> §6.17 and Annex A.2.2; RFC 9584; RFC 9639 §8.2 and §9.1.2; RFC 7845 §5.1. Not openly
> readable, and so not read: ISO/IEC 21122-1, ISO/IEC 23094-1, ISO/IEC 23094-2, ISO/IEC
> 23008-3, ISO/IEC 14496-1, ISO/IEC 14496-15, ISO/IEC 23888-2, ISO/IEC 23888-4, T/AI 109.2,
> T/AI 109.3 and IEEE 1857.11-2024. For those formats §3 to §10 and §16 to §19 say where each
> layout was read instead, or that it was not. Openly readable and not read: 3GPP TS 26.201 (§17.3).

## 1. Scope

§1.1 A probe reads a payload's headers. It identifies the format by the bytes the format
begins with, where it has such bytes (§2.4), reads the parameters its headers state, and checks
the structure the probe reads: the order of the format's required structures, the lengths they
declare, and the values the format forbids or reserves among the fields read. It reads no
coded sample data: a payload a probe accepts is not shown to decode, and a probe that accepts a
payload says nothing of the pictures or sounds in it.

§1.2 What a probe gives is used to describe a payload without decoding it: in a catalogue, in a
manifest a packager writes, in the `codecs` string or media-type parameters a delivery binding
states (§3.5), and to refuse a payload that does not hold the format its capability names before
any decoder sees it.

§1.3 An encoder **MUST NOT** emit, under a capability whose probe has basis `standard` or `wai`
(§2.3), a payload that probe refuses; it **SHOULD NOT** emit one that a probe of basis
`implementation` refuses. A sink **MAY** probe a payload before it dispatches it (SPEC §4); a
sink that probes and gets a refusal does not dispatch the payload under that capability, and
may still take dispatch step 5 with a fallback. A probe's refusal is not a statement that the
payload does not conform to its format's standard: a probe of basis `implementation` reads the
layout its sources give, and §12's `outside_probe` names payloads it cannot read at all.

§1.4 This extension adds no capability. It completes the registrations of `wai.video.vvc`,
`wai.video.lcevc`, `wai.audio.mpegh`, `wai.video.avs3`, `wai.audio.avs3`, `wai.video.av2`,
`wai.audio.ac4`, `wai.audio.iamf` and `wai.audio.ivas`, which were registered with no probe,
and gives the registrations of `wai.image.jxs`, `wai.video.jxs`, `wai.video.mvhevc`,
`wai.image.ieee1857_11` and `wai.meta.projection` (SPEC §5) theirs. None of these is in the
mandatory floor or the recommended set, and a probe puts none there.

## 2. Common rules

§2.1 A probe's result is a JSON object whose members each section names; a member the payload
does not state is `null`. Integers are JSON numbers, flags JSON booleans. The probe reports the
first refusal its reading meets, in the order each section reads.

§2.2 A bit reader reads most significant bit first. `u(n)` is an `n`-bit unsigned integer;
`ue(v)` is the Exp-Golomb code of ITU-T H.265 §9.2, and one with more than 31 leading zero bits
is `reserved_value`. Reading past the payload's end is `truncated`.

§2.3 Every probe has a **basis**: `standard`, where its format's own text is openly readable and
was read; `implementation`, where it is not and the layout was read from open implementations,
each section naming which agree; `wai`, for a format this specification defines.

§2.4 The probes, in order:

| capability | basis | section |
|---|---|---|
| `wai.image.jxs` | implementation | §3 |
| `wai.video.jxs` | implementation | §3.3 |
| `wai.video.hevc` | standard | §4 |
| `wai.video.mvhevc` | standard | §4 |
| `wai.video.vvc` | standard | §5 |
| `wai.video.lcevc` | implementation | §6 |
| `wai.audio.mpegh` | implementation | §7 |
| `wai.video.avs3` | implementation | §8 |
| `wai.audio.avs3` | implementation | §9 |
| `wai.image.ieee1857_11` | implementation | §10 |
| `wai.meta.projection` | wai | §11 |
| `wai.video.av2` | standard | §14 |
| `wai.audio.ac4` | standard | §15 |
| `wai.audio.iamf` | standard | §16 |
| `wai.audio.ivas` | standard | §17 |

Any other capability has no probe: `no_probe`; §18 says why `wai.video.evc` and
`wai.video.evc.baseline` have none, and §19 why `wai.video.vcm` and `wai.tensor.fcm` have none.

§2.5 **Annex B byte streams.** A payload of H.265, H.266 or LCEVC is a byte stream: after any
zero bytes, it begins with the start code prefix `0x000001`, and otherwise is `no_signature`
(one zero byte before the prefix is not enough: at least two). A NAL unit is the bytes after a
prefix up to the next prefix, less the zero bytes that end it. Its payload is read with every
emulation-prevention byte removed: the `0x03` of every `0x000003` (ITU-T H.265 §7.4.2).

§2.6 **Codec strings.** The probes of §14 to §17 give `codec`: the value of the RFC 6381
`codecs` parameter that the format's own binding defines for the payload read, or `null` where
the binding defines none or the payload does not give its fields. A sink uses it as
[platform-decode](platform-decode.md) §2.5 says. No other probe gives `codec`.

## 3. JPEG XS

§3.1 **Sources.** ISO/IEC 21122-1 is not openly readable. The marker codes, the segment
layouts and the order of §3.2 are those two independent open implementations of the codestream
agree on, a decoder and encoder under BSD-2-Clause-Patent and a decoder under MIT, at the
revisions `format-probe-conformance/tools/make_external.sh` pins. The profile codes are ISO/IEC
21122-2:2022/Amd 1:2022 Table A.7, and the sublevel codes its Table A.16, read in the
amendment's public preview. Level codes are named only where the two open readings agree
(§3.4).

§3.2 **The codestream.** A `wai.image.jxs` payload is one codestream. A probe reads, in order:

1. `SOC`, `0xFF10`, as the first two bytes; otherwise `no_signature`.
2. `CAP`, `0xFF50`, immediately after, and otherwise `out_of_order`; its length `Lcap`, a
   big-endian `u16` of at least 2 (else `length_mismatch`), counts itself and `Lcap − 2` bytes of
   capability bits, read most significant bit first: bit `i` set is reported in `cap_bits`.
3. `PIH`, `0xFF12`, immediately after `CAP`, else `out_of_order`, with `Lpih` 26, else
   `length_mismatch`. Its body, big-endian: `Lcod` 32 bits, `Ppih` 16, `Plev` 16, `Wf` 16, `Hf`
   16, `Cw` 16, `Hsl` 16, `Nc` 8, `Ng` 8, `Ss` 8, `Bw` 8, `Fq` 4, `Br` 4, `Fslc` 1, `Ppoc` 3,
   `Cpih` 4, `Nlx` 4, `Nly` 4, `Lh` 1, `Rl` 1, `Qpih` 2, `Fs` 2, `Rm` 2. It is `reserved_value`
   unless `Wf`, `Hf` and `Hsl` are at least 1, `Nc` is 1 to 8, `Ng` is 4, `Ss` is 8, `Br` is 4,
   `Cpih` is 0, 1 or 3, and `Qpih` is 0 or 1.
4. Segments up to the first slice header `SLH`, `0xFF20`, each a marker, a big-endian `u16`
   length of at least 2 (else `length_mismatch`) and that many bytes less two: `CDT` `0xFF13`,
   `WGT` `0xFF14`, `COM` `0xFF15`, `NLT` `0xFF16`, `CWD` `0xFF17`, `CTS` `0xFF18`, `CRG`
   `0xFF19`, in any order. `CDT`'s length is `2 + 2·Nc`, else `length_mismatch`; it holds, per
   component, its precision `B` (8 bits) and its sampling factors `Sx` and `Sy` (4 bits each),
   none of which is 0 (else `reserved_value`). `SOC`, `EOC`, `PIH` or `CAP` among these segments is
   `out_of_order`; any other marker is `reserved_value`.
5. `CDT` and `WGT` are required before `SLH`, and with `Cpih` 3 also `CTS` and `CRG`:
   `missing_structure`. The payload ends with `EOC`, `0xFF11`: otherwise `missing_structure`.
6. `Lcod` is 0 (a variable-rate codestream) or the codestream's length in bytes, `SOC` to `EOC`;
   otherwise `length_mismatch`.

The probe does not read the slices.

§3.3 **Video.** A `wai.video.jxs` payload is five `u32` little-endian values, `n`, `h`, `w`,
`fps_num` and `fps_den`, then `n` codestreams, each preceded by its length as a `u32`
little-endian value: the framing of `wai.video.av1` (SPEC §5), with a codestream for a temporal
unit. Any of the five being 0 is `framing_invalid`; a length past the payload's end is
`truncated`; each codestream is probed by §3.2, and one whose `Wf` exceeds `w` or whose `Hf`
exceeds `h` is `framing_invalid`; bytes after the `n`-th codestream are `trailing_bytes`.

§3.4 **Parameters.** For one codestream: `profile` and `level` (`Ppih` and `Plev` as four
lowercase hexadecimal digits after `0x`), `width` and `height` (`Wf`, `Hf`), `components` (per
component `[B, Sx, Sy]`), `structure`, `colour_transform` (`Cpih`), `decompositions`
(`[Nlx, Nly]`), `precinct_width` (`Cw`), `slice_height` (`Hsl`), `wavelet_precision` (`Bw`),
`fractional_bits` (`Fq`), `quantizer` (`Qpih`), `long_header` (`Lh`), `raw_mode` (`Rl`),
`cbr_bytes` (`Lcod`), `cap_bits`, and `rtp` (§3.5). `structure` is `"4:4:4"`, `"4:2:2"` or
`"4:2:0"` when there are at least three components, the first has `Sx` = `Sy` = 1 and the second
and third have equal factors of (1, 1), (2, 1) or (2, 2) respectively; otherwise `null`.

For a video: `frames` (`n`), `size` (`[w, h]`), `fps` (`[fps_num, fps_den]`),
`constant_bytes` (the common `Lcod` when every codestream states the same non-zero `Lcod`,
otherwise `null`) and `first`, the first codestream's parameters.

The profile names (white space omitted, as RFC 9134 §7.1 writes them), by `Ppih`:

| `Ppih` | profile | `Ppih` | profile |
|---|---|---|---|
| `0x0000` | Unrestricted | `0x4240` | High420.12 |
| `0x1500` | Light422.10 | `0x4A40` | High444.12 |
| `0x1A00` | Light444.12 | `0x4E40` | High4444.12 |
| `0x2500` | Light-Subline422.10 | `0x6EC0` | MLS.12 |
| `0x3240` | Main420.12 | `0x9300` | LightBayer |
| `0x3540` | Main422.10 | `0xB340` | MainBayer |
| `0x3A40` | Main444.12 | `0xC340` | HighBayer |
| `0x3E40` | Main4444.12 | | |

The level, by `Plev`'s high byte: `0x00` Unrestricted, `0x10` 2k-1, `0x20` 4k-1, `0x24` 4k-2,
`0x28` 4k-3, `0x30` 8k-1, `0x34` 8k-2, `0x38` 8k-3, `0x40` 10k-1. The high bytes `0x04` and
`0x2C` are named 1k-1 and 5k-1 by one open implementation and refused as reserved by the other;
the probe names them too, and §3.6 records the disagreement. The sublevel, by `Plev`'s low byte:
`0x00` Unrestricted, `0x80` Full, `0x10` Sublev12bpp, `0x0C` Sublev9bpp, `0x08` Sublev6bpp,
`0x06` Sublev4bpp, `0x04` Sublev3bpp, `0x03` Sublev2bpp. A code in none of these lists is
reported with a `null` name and is not refused: a later edition may define it.

§3.5 **RTP and SMPTE ST 2110-22.** RFC 9134 carries a JPEG XS codestream in RTP; SMPTE ST
2110-22:2022 carries constant-bit-rate compressed video over RTP and names no codec. A sender of
a `wai.video.jxs` payload over RFC 9134:

- states the media type `video/jxsv` with the parameters of `rtp` (RFC 9134 §7.1): `profile`,
  `level` and `sublevel` by the names of §3.4 (omitted where `null`), `depth` (the largest
  component precision), `width` and `height`, and `sampling` where the codestream determines it:
  `RGB` where `structure` is `4:4:4` under a colour transform (`Cpih` 1 or 3), whose decoder
  outputs R, G and B; otherwise `rtp.sampling` is `null` and the sender states the sampling,
  since a codestream does not say whether its components are Y′C′BC′R, constant-luminance
  Y′C′BC′R or ICTCP (RFC 9134 §7.1 lists all three);
- sends each codestream as one picture segment of codestream mode (`K` = 0, RFC 9134 §4.1) at
  the frame rate `fps`, the RTP timestamp at 90 kHz (RFC 9134 §4.2), or each slice in slice mode
  (`K` = 1);
- for SMPTE ST 2110-22 (§4 there: a constant number of bytes, and of RTP packets, per frame),
  sends only a payload whose `constant_bytes` is not `null`; the codestream's `Lcod` is the
  frame's byte count.

A receiver rebuilds the payload by framing each received codestream as §3.3 does, `fps` from
the session's `exactframerate`. WAI defines no transport (moq-streaming-format §6); this
mapping says which of a payload's fields fill which of RFC 9134's.

§3.6 **Exactness.** A sink that advertises `wai.image.jxs` or `wai.video.jxs` decodes at the
strict conformance point of ISO/IEC 21122-4 (Annex B.2: decoded images bitwise identical to the
reference images), not only at its relaxed point (PSNR bounds), so every conforming sink outputs
the same samples; the registry class is `standard-defined` on that basis. What was measured
(`format-probe-conformance/provenance.json`): the open decoder's C path and SIMD path give
byte-identical output on every JPEG XS vector of the corpus, on arm64; the second, independent
decoder gives the same bytes on every vector whose profile it implements, five of six; it does
not implement MLS.12 (it refuses `Ppih` `0x6EC0`), and on a copy of that vector with `Ppih` and
`Plev` set to 0 its output differs, while the first decoder's output equals the vector's source
picture byte for byte, as a lossless codestream's must. No x86 decode was measured.

## 4. H.265 and MV-HEVC

§4.1 **Sources.** ITU-T H.265 (V11, 01/2026): the NAL unit header (§7.3.1.2), the video
parameter set and its extension (§F.7.3.2.1, §F.7.3.2.1.1, derivations (F-2) to (F-6)), the
sequence parameter set (§7.3.2.2.1), profile_tier_level (§7.3.3, inference §F.7.4.4) and the HRD
parameters (§E.2.2, §E.2.3).

§4.2 **NAL units.** Each NAL unit (§2.5) is at least 2 bytes (else `truncated`); its header is
`forbidden_zero_bit` 1, `nal_unit_type` 6, `nuh_layer_id` 6, `nuh_temporal_id_plus1` 3 bits.
`forbidden_zero_bit` 1 or `nuh_temporal_id_plus1` 0 is `reserved_value`. Types 0 to 31 are VCL.
The probe reads the first VPS (type 32) and the first SPS (type 33) with `nuh_layer_id` 0. A VCL
NAL unit before both is `out_of_order` if both occur later in the payload and `missing_structure`
if either never does; a payload with no VCL NAL unit is `missing_structure`.

§4.3 **The VPS.** In order: `vps_video_parameter_set_id` u(4), `vps_base_layer_internal_flag`,
`vps_base_layer_available_flag`, `vps_max_layers_minus1` u(6), `vps_max_sub_layers_minus1` u(3)
(above 6 is `reserved_value`), `vps_temporal_id_nesting_flag`, `vps_reserved_0xffff_16bits` (any
other value is `reserved_value`), profile_tier_level(1, `vps_max_sub_layers_minus1`), the
sub-layer ordering information, `vps_max_layer_id` u(6), `vps_num_layer_sets_minus1` ue(v)
(above 1023 is `reserved_value`), the layer-id flags, the timing information with its HRD
parameters (`vps_num_hrd_parameters` above `vps_num_layer_sets_minus1` + 1 is `reserved_value`;
`cpb_cnt_minus1` above 31 is `reserved_value`), and `vps_extension_flag`. When the flag is 1 and
`vps_max_layers_minus1` is above 0, the probe reads the alignment bits (each 1, else
`reserved_value`) and `vps_extension( )` up to and including its profile_tier_level( )
structures: `splitting_flag`, the sixteen `scalability_mask_flag`s, the dimension lengths, the
layer ids (each above the one before, else `reserved_value`), the dimension ids, `view_id_len`
and the view ids, the direct dependency flags, `num_add_layer_sets` and its
`highest_layer_idx_plus1` fields, the sub-layer and inter-layer temporal fields,
`default_ref_layers_active_flag`, `vps_num_profile_tier_level_minus1` (above 63 is
`reserved_value`) and the structures it counts. A profile_tier_level( ) is read as §7.3.3 lays it
out, its general profile part as 88 bits whatever its branches (the syntax's own note). A
structure with no profile takes its profile, tier and compatibility flags from the structure
before it (§F.7.4.4).

§4.4 **The SPS** of the base layer: `sps_video_parameter_set_id` u(4), `sps_max_sub_layers_minus1`
u(3) (above 6 is `reserved_value`), `sps_temporal_id_nesting_flag`, profile_tier_level(1, ·),
`sps_seq_parameter_set_id` ue(v) (above 15 is `reserved_value`), `chroma_format_idc` ue(v) (above
3 is `reserved_value`), `separate_colour_plane_flag` when it is 3, `pic_width_in_luma_samples`
and `pic_height_in_luma_samples` ue(v) (0 is `reserved_value`), the conformance window, and
`bit_depth_luma_minus8` and `bit_depth_chroma_minus8` ue(v) (above 8 is `reserved_value`). The
cropped size is the coded size less the window, whose offsets count SubWidthC and SubHeightC
samples (2 and 2 at 4:2:0, 2 and 1 at 4:2:2, 1 and 1 otherwise); a window as large as the
picture is `reserved_value`.

§4.5 **MV-HEVC.** A `wai.video.mvhevc` payload is also refused `not_multiview` unless the VPS
extension's scalability mask has bit 1 (multiview, Table F.1), `NumViews` (F-3) is at least 2, and
a VCL NAL unit with `nuh_layer_id` above 0 is present.

§4.6 **Parameters.** `profile_idc`, `tier`, `level_idc` (the base SPS's), `chroma_format_idc`,
`bit_depth` (`[luma, chroma]`), `coded` and `cropped` (`[width, height]`), `layers`
(`Min(62, vps_max_layers_minus1)` + 1), `layers_present` (the `nuh_layer_id`s of the VCL NAL units,
ascending), and, when the VPS extension was read, `multilayer`: `scalability_mask` (bit `i` for
`scalability_mask_flag[ i ]`), `layer_ids`, `view_order` and `aux` (`ViewOrderIdx` and `AuxId` per
layer), `views` (`NumViews` when the multiview bit is set, else 1), `view_ids` (`view_id_val`, or
zeros when `view_id_len` is 0), `profiles` (`general_profile_idc` of each extension structure,
after inference) and `multiview_profile` (whether any of them indicates profile 6, Multiview Main
or Multiview Main 10, by its idc or its compatibility flag).

## 5. H.266

§5.1 **Sources.** ITU-T H.266 (V4, 01/2026) §7.3.1.2, §7.3.2.3, §7.3.2.4, §7.3.3.1 and §7.3.3.2.

§5.2 **NAL units.** The header is `forbidden_zero_bit` 1, `nuh_reserved_zero_bit` 1,
`nuh_layer_id` 6, `nal_unit_type` 5, `nuh_temporal_id_plus1` 3 bits. Either of the first two set,
`nuh_temporal_id_plus1` 0 or `nuh_layer_id` above 55 is `reserved_value`. Types 0 to 11 are VCL.
The probe reads the first SPS (type 15) and the first VPS (type 14), of which it reads
`vps_max_layers_minus1` (the second field, after a 4-bit id). A VCL NAL unit before the SPS is
`out_of_order` if an SPS occurs later and `missing_structure` if none does; no VCL NAL unit is
`missing_structure`.

§5.3 **The SPS** to its conformance window: `sps_seq_parameter_set_id` u(4),
`sps_video_parameter_set_id` u(4), `sps_max_sublayers_minus1` u(3) (above 6 is `reserved_value`),
`sps_chroma_format_idc` u(2), `sps_log2_ctu_size_minus5` u(2) (above 2 is `reserved_value`),
`sps_ptl_dpb_hrd_params_present_flag` and, when it is 1, profile_tier_level(1,
`sps_max_sublayers_minus1`), `sps_gdr_enabled_flag`, `sps_ref_pic_resampling_enabled_flag` and
the flag it conditions, `sps_pic_width_max_in_luma_samples` and
`sps_pic_height_max_in_luma_samples` ue(v) (0 is `reserved_value`), and the conformance window.
profile_tier_level( ) is read as §7.3.3.1 lays it out; general_constraints_info( ) is
`gci_present_flag`, then, when it is 1, 71 bits of constraints, `gci_num_additional_bits` u(8)
and that many bits, then zero bits to the byte boundary (a one among them is `reserved_value`).
The cropped size is computed as in §4.4.

§5.4 **Parameters.** `profile_idc`, `tier`, `level_idc`, `frame_only`
(`ptl_frame_only_constraint_flag`) and `multilayer_enabled` (`ptl_multilayer_enabled_flag`), all
`null` when the SPS carries no profile_tier_level( ); `sub_profiles` (`general_sub_profile_idc`s);
`chroma_format_idc`; `ctu_size` (`1 << (sps_log2_ctu_size_minus5 + 5)`); `coded`; `cropped`;
`layers` (`vps_max_layers_minus1` + 1, or 1 without a VPS); `layers_present`.

## 6. LCEVC

§6.1 **Sources.** ISO/IEC 23094-2 is not openly readable. The NAL unit header, the block
structure and the two configurations are those an open decoder (BSD-3-Clause-Clear) and an open
syntax reading under LGPL-2.1 agree on, each citing the standard's tables; the resolution table
is the standard's Table 20 as the decoder reproduces it. The two readings disagree on the byte
that extends a profile or level of 15; the probe does not read it (`outside_probe`).

§6.2 **NAL units.** A `wai.video.lcevc` payload is the byte stream of SPEC §5 (§2.5). Each NAL
unit is at least 3 bytes (else `truncated`). Its first byte is `forbidden_zero_bit` (0),
`forbidden_one_bit` (1), `nal_unit_type` (5 bits) and the first bit of `reserved_flag` (1); its
second byte is the other eight bits of `reserved_flag`, all 1. Any other value of those bits is
`reserved_value`. `nal_unit_type` is 29 (IDR) or 28 (non-IDR), else `reserved_value`; the first NAL
unit is IDR, else `out_of_order`. The payload, emulation prevention removed, ends with the byte
`0x80`, else `reserved_value`.

§6.3 **Blocks.** The payload before that byte is a sequence of blocks: a header byte, its high
three bits `payload_size_type` and its low five `payload_type`, then the body. A size type of 0 to
5 is the body's length; 6 is `reserved_value`; 7 is followed by the length as a multi-byte value:
seven bits a byte, most significant first, each byte but the last with its top bit set, at most
ten bytes (else `reserved_value`). A body past the payload's end is `length_mismatch`. Types: 0
sequence configuration, 1 global configuration, 2 picture configuration, 3 and 4 encoded data,
5 additional information, 6 filler; the probe reads the first 0 and the first 1, counts the 2s,
and passes over the rest. A picture configuration before both configurations is `out_of_order`;
a payload without both is `missing_structure`.

§6.4 **The configurations.** The sequence configuration: `profile_idc` 4, `level_idc` 4,
`sublevel_idc` 2, `conformance_window_flag` 1, five reserved bits that are 0 (else
`reserved_value`); a profile or level of 15 is `outside_probe`; with the flag, four multi-byte
window offsets (left, right, top, bottom); bytes left in the body are `length_mismatch`. The
global configuration: `processed_planes_type_flag` 1, `resolution_type` 6, `transform_type` 1,
`chroma_sampling_type` 2, `base_depth_type` 2, `enhancement_depth_type` 2,
`temporal_step_width_modifier_signalled_flag` 1, `predicted_residual_mode_flag` 1,
`temporal_tile_intra_signalling_enabled_flag` 1, `temporal_enabled_flag` 1, `upsample_type` 3,
`level1_filtering_signalled_flag` 1, `scaling_mode_level1` 2, `scaling_mode_level2` 2,
`tile_dimensions_type` 2, `user_data_enabled` 2, `level1_depth_flag` 1, `chroma_step_width_flag`
1; then, each where its condition holds: a byte of planes type (the planes flag), a byte of step
width modifier (its flag), four 16-bit kernel coefficients (`upsample_type` 4), a byte of two
filter coefficients (the filtering flag), for `tile_dimensions_type` above 0 the custom tile
width and height as 16-bit values when it is 3 and then a byte of tile compression, and, for
`resolution_type` 63, the custom width and height as 16-bit values. `resolution_type` 0 or 51 to
62, an `upsample_type` above 4, or a custom width or height of 0 is `reserved_value`.

§6.5 **Parameters.** `nal_units` (`[IDR, non-IDR]` counts), `pictures` (picture configurations),
`profile_idc`, `level_idc`, `sublevel_idc`, `conformance_window` (the four offsets as signalled,
or `null`), `resolution_type`, `size` (Table 20's for types 1 to 50, the custom size for 63),
`transform_type`, `chroma_sampling_type`, `base_depth` and `enhancement_depth` (`8 + 2·type`),
`temporal_enabled`, `upsample_type`, `tile_dimensions_type`.

Table 20, types 1 to 50: 360×200, 400×240, 480×320, 640×360, 640×480, 768×480, 800×600,
852×480, 854×480, 856×480, 960×540, 960×640, 1024×576, 1024×600, 1024×768, 1152×864,
1280×720, 1280×800, 1280×1024, 1360×768, 1366×768, 1400×1050, 1440×900, 1600×1200, 1680×1050,
1920×1080, 1920×1200, 2048×1080, 2048×1152, 2048×1536, 2160×1440, 2560×1440, 2560×1600,
2560×2048, 3200×1800, 3200×2048, 3200×2400, 3440×1440, 3840×1600, 3840×2160, 3840×2400,
4096×2160, 4096×3072, 5120×2880, 5120×3200, 5120×4096, 6400×4096, 6400×4800, 7680×4320,
7680×4800.

## 7. MPEG-H 3D Audio

§7.1 **Sources.** ISO/IEC 23008-3 is not openly readable. The MHAS packet syntax, the packet
types and the first fields of the configuration are those two independent open decoders agree
on; the low-complexity profile-level codes 0x0B to 0x0D are confirmed by ATSC A/342-3:2024-04
§5.2.2.1. Neither open decoder is under a licence this corpus can use, so the corpus's MHAS
vectors are written by its generator (§13.2).

§7.2 **Packets.** A `wai.audio.mpegh` payload is an MHAS stream: packets, each a header of
`MHASPacketType` = escapedValue(3, 8, 8), `MHASPacketLabel` = escapedValue(2, 8, 32) and
`MHASPacketLength` = escapedValue(11, 24, 24), then that many bytes. escapedValue(n1, n2, n3)
reads `v` = u(n1); when `v` is 2^n1 − 1 it reads `a` = u(n2) and adds it; when `a` is
2^n2 − 1 it reads u(n3) and adds that too. Every header is a whole number of bytes. The first
packet is a synchronisation packet (type 6) or a configuration packet (type 1), else
`no_signature`; a packet past the end is `truncated`. A synchronisation packet has label 0 and the
one byte `0xA5`, else `reserved_value`. A frame packet (type 2) before the first configuration is
`out_of_order`; a payload with no configuration is `missing_structure`. Other types are passed
over.

§7.3 **The configuration.** The first configuration packet's payload: the profile-level
indication u(8); `usacSamplingFrequencyIndex` u(5), its rate by the table below, or, for 31, a
rate u(24) (0 is `reserved_value`); `coreSbrFrameLengthIndex` u(3); one reserved bit;
`receiverDelayCompensation` u(1); `speakerLayoutType` u(2); then, for type 0,
`CICPspeakerLayoutIdx` u(6), and for types 1 and 2 the speaker count, escapedValue(5, 8, 16) + 1.
Rates by index 0 to 30: 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000,
11025, 8000, 7350, reserved, reserved, 57600, 51200, 40000, 38400, 34150, 28800, 25600, 20000,
19200, 17075, 14400, 12800, 9600, reserved, reserved, reserved; a reserved index is
`reserved_value`.

§7.4 **Parameters.** `profile_level`; `profile` and `level`: `low-complexity` 1 to 5 for 0x0B to
0x0F, `baseline` 1 to 5 for 0x10 to 0x14, else `null`; `sampling_rate`; `core_frame_length_index`;
`speaker_layout_type`; `cicp_layout`; `speakers`; and the counts `packets`, `frames`, `syncs` and
`configs`.

## 8. AVS3 video

§8.1 **Sources.** T/AI 109.2 is not openly readable. The sequence header and the pseudo-start-code
prevention are read as an open decoder (BSD-3-Clause) reads them, with the start codes it and an
open syntax reading under LGPL-2.1 agree on. ETSI TS 101 154 V2.10.1 §5.16.2 requires the library
flags to be 0 and confirms the profile codes 0x20, 0x22 and 0x32.

§8.2 **Units.** A `wai.video.avs3` payload begins, after any zero bytes (at least two), with the
prefix `0x000001`, else `no_signature`. A unit is the byte after a prefix (its start code) and the
bytes up to the next prefix. A unit's bytes are read with the prevention bits removed: in each
byte `0x02` that follows two zero bytes of the unit, its two low bits. Start codes: `0xB0`
sequence header, `0xB1` sequence end, `0xB3` intra picture, `0xB6` inter picture. A payload with no
sequence header is `missing_structure`; one whose first unit is not one is `out_of_order`; one
with no intra picture is `missing_structure`.

§8.3 **The sequence header.** `profile_id` u(8), `level_id` u(8), `progressive_sequence` u(1),
`field_coded_sequence` u(1), `library_stream_flag` u(1) (1 is `outside_probe`),
`library_picture_enable_flag` u(1) (1 is `outside_probe`: a flag follows whose place the open
texts do not establish), `marker_bit`, `horizontal_size` u(14), `marker_bit`, `vertical_size` u(14),
`chroma_format` u(2), `sample_precision` u(3), `encoding_precision` u(3) for profiles 0x22 and
0x32 only, `marker_bit`, `aspect_ratio` u(4), `frame_rate_code` u(4), `marker_bit`,
`bit_rate_lower` u(18), `marker_bit`, `bit_rate_upper` u(12), `low_delay` u(1),
`temporal_id_enable_flag` u(1), `marker_bit`, `bbv_buffer_size` u(18), `marker_bit`,
`max_dpb_size_minus1` u(4). A `marker_bit` of 0 is `reserved_value`, and so are a size, chroma
format or sample precision of 0 and a frame rate code of 0 or above 13.

§8.4 **Parameters.** `profile_id`, `level_id`, `progressive`, `field_coded`, `size`,
`chroma_format`, `sample_precision`, `encoding_precision` (or `null`), `aspect_ratio`,
`frame_rate_code`, `bit_rate` (`bit_rate_upper` · 2^18 + `bit_rate_lower`), `low_delay`,
`temporal_id_enabled`, `bbv_buffer_size`, `max_dpb_size`, `pictures` (`[intra, inter]` counts) and
`sequence_end` (whether a sequence end unit is present).

## 9. AVS3 audio

§9.1 **Sources.** T/AI 109.3 is not openly readable. The frame header is read as an open
demultiplexer under LGPL-2.1 reads it; ETSI TS 101 154 V2.10.1 §6.10.2 constrains the values a
broadcast stream uses. The demultiplexer reads only the lossy codec and refuses ancillary data,
and the probe does the same (`outside_probe`). It also skips two 8-bit fields it does not name,
and so does the probe. The header states no frame length, so the probe reads the first frame's
header only.

§9.2 **The header.** A sync word of 12 bits, `0xFFF` (else `no_signature`); `audio_codec_id` u(4)
(1, lossless, is `outside_probe`; anything but 2 is `reserved_value`); `anc_data` u(1) (1 is
`outside_probe`); `nn_type` u(3) (above 1 is `reserved_value`); `coding_profile` u(3) (above 2 is
`reserved_value`); `sampling_frequency_index` u(4), rates 192000, 96000, 48000, 44100, 32000,
24000, 22050, 16000, 8000 (above 8 is `reserved_value`); 8 bits; then for profile 0
`channel_number_index` u(7); for profile 1 `soundbed_type` u(2): for 0 the object count less one
u(7) and the per-object bitrate index u(4), for 1 `channel_number_index` u(7), the bitrate index
u(4), the object count less one u(7) and the per-object bitrate index u(4), and above 1
`reserved_value`; for profile 2 the ambisonic order less one u(4) (an order outside 1 to 3 is
`reserved_value`); then `resolution` u(2) (above 2 is `reserved_value`), the bitrate index u(4)
unless the profile is 1, and 8 bits.

§9.3 **Parameters.** `codec_id`, `nn_type`, `coding_profile`, `sampling_rate`, and as the profile
gives them `channel_number_index`, `soundbed_type`, `objects`, `bitrate_index`,
`bitrate_index_per_object`, `ambisonic_order`; and `resolution_bits` (8 · (`resolution` + 1)).

## 10. IEEE 1857.11

§10.1 `wai.image.ieee1857_11` is a candidate (SPEC §5): IEEE 1857.11-2024 is not openly readable,
and the open reference software (BSD-2-Clause) writes a picture header with no start code, from a
working draft, marking the code that would write one as not yet written. So no payload format is
pinned. This parse reads that header as the software's writer lays it out, at the revision the
corpus README names. Its reader masks `level_id` differently from its writer; the parse follows
the writer. With no signature, the parse cannot tell this format from another; it reads a payload
declared to be one, and never refuses `no_signature`.

§10.2 **The header**, big-endian: 3 bytes holding `profile_id` (3 bits), `level_id` (6),
`model_id` (3), `parameter_set_id` (7) and `quality_id` (5); the picture's height and width as
32-bit values; 2 bytes holding 2 unused bits (0), `output_bit_depth` (3), `picture_format` (3),
`log2_slice_size_h_minus6` (4) and `log2_slice_size_w_minus6` (4). Fewer than 13 bytes is
`truncated`. A `profile_id` above 2, an unused bit set, an `output_bit_depth` other than 1 (8
bits) or 2 (10 bits), or a height or width of 0 is `reserved_value`.

§10.3 **Parameters.** `profile_id`, `level_id`, `model_id`, `parameter_set_id`, `quality_id`,
`size` (`[width, height]`), `bit_depth`, `picture_format`, `slice_size`
(`[2^(w+6), 2^(h+6)]`).

## 11. The projection descriptor

§11.1 The probe of `wai.meta.projection` reads the descriptor as [projection](projection.md) §3
lays it out and checks it as its §4 does; its parameters are those of projection.md §3. The
check of a descriptor against the rendition it accompanies, which needs that rendition's probe,
is projection.md §5's.

## 12. Refusals

| code | meaning |
|---|---|
| `no_signature` | the payload does not begin with the format's signature |
| `truncated` | the bytes end inside a structure the probe reads |
| `out_of_order` | a structure is where the format does not allow it |
| `reserved_value` | a field holds a value the format forbids or reserves |
| `length_mismatch` | a length a structure declares disagrees with the bytes |
| `missing_structure` | a structure the format requires is absent |
| `not_multiview` | a `wai.video.mvhevc` payload with no second view |
| `framing_invalid` | the framing of a `wai.video.jxs` payload is wrong |
| `trailing_bytes` | bytes follow the end of the payload's last structure |
| `descriptor_invalid` | a projection descriptor's fields disagree with each other |
| `layer_absent` | a projection descriptor names a layer its rendition does not hold |
| `outside_probe` | the payload uses a feature whose syntax the probe's sources do not establish |
| `no_probe` | no probe is defined for the capability |

## 13. Conformance

§13.1 [`format-probe-conformance/`](../format-probe-conformance/) holds `vectors.json`: every
vector's capability, file, SHA-256, origin and outcome (its parameters, or its refusal), the
projection descriptors' bindings with theirs (projection.md §5), and the facts of §13.2.

§13.2 **External vectors** (`ext/`) were written by permissively licensed encoders at pinned
revisions from synthetic pictures, and each was decoded again; `tools/make_external.sh` writes
them and `provenance.json`, which records every command and decode. **Facts** are what each
encoder was asked for (a size, a profile, a view count): the probe must read them, which ties the
probe to the encoder and not to itself. **Generated vectors** (`gen/`) are written by
`wai_format_probe gen` from fixed values and from the external vectors: the formats no
permissively licensed encoder writes (LCEVC, MHAS, AVS3 audio, the IEEE 1857.11 header, the
projection descriptor), the vectors of §14 to §17, and the negative controls, each refused with
a code of §12, every code given. The vectors of AV2, AC-4, IAMF and IVAS are built by hand from
the syntax of §14 to §17, with known field values; no encoder or decoder of those formats was
run for them. Past the fields their probes read they hold fixed filler, so they are not
decodable streams.

§13.3 **Fetched vectors.** `fetch.sh` fetches five LCEVC streams an open decoder's tests use,
written by an LCEVC encoder, and checks each SHA-256; the corpus names them and does not hold
them, because their licence notice names their owner. Each is a container of blocks (an 8-byte
magic `lcevcbin`, a `u32` version, then per block a `u16` type, a `u32` size and that many bytes,
the first 16 of which are two indices) whose remaining bytes, concatenated, are the byte stream.
`vectors.json` states, for each, what its encoder was asked for.

§13.4 `wai_format_probe verify` and `wai-rs/tests/format_probe.rs` require every outcome, binding
and fact, and the generated files byte for byte; with `--fetched` the verifier requires every
fetched stream. `format_probe_verify.py`, written from this text and projection.md and sharing no
code with wai-rs, does the same, and requires every mutated copy of the corpus to fail.

## 14. AV2

§14.1 **Sources.** The AV2 Bitstream & Decoding Process Specification v1.0.0 (28 May 2026):
`uvlc()` and `leb128()` (§4.11.3, §4.11.6), the OBU header (§5.2.2, Table 6.1, §6.2.2), the
sequence header OBU (§5.4.1, §6.4.1, Tables 6.2 and 6.3), the order of a temporal unit
(§7.3.7), the profiles and levels (Annex A, Tables A.1 and A.7), and the length-delimited
bitstream (Annex B), the framing SPEC §5 registers.

§14.2 **OBUs.** A `wai.video.av2` payload is the length-delimited bitstream: OBUs back to back,
each preceded by its length `num_bytes_in_obu` as a `leb128()`: seven bits a byte, least
significant group first, a byte's top bit set when another follows, at most eight bytes and a
value of at most 2^32 − 1 (else `reserved_value`). The payload's first OBU is a temporal
delimiter (`obu_type` 2), as every temporal unit's is (§7.3.7); otherwise `no_signature`. An OBU
past the payload's end is `truncated`; one shorter than its header is `length_mismatch`. The
header is `obu_header_extension_flag` 1, `obu_type` 5 and `obu_tlayer_id` 2 bits, then, with the
flag, `obu_mlayer_id` 3 and `obu_xlayer_id` 5 bits; without it the embedded layer is 0, and the
extended layer is 31 (`GLOBAL_XLAYER_ID`) for a temporal delimiter or a multistream decoder
operation OBU (`obu_type` 20) and 0 for any other. Once the payload is split, in order of the
OBUs: a temporal delimiter or multistream decoder operation OBU of an extended layer other than
31, and a sequence header OBU (`obu_type` 1) of a temporal or embedded layer other than 0, are
`reserved_value` (§6.2.2). The OBUs that carry a coded frame are of types 4 to 7, 10 to 14, 19
and 21 (§5.2.1). A payload without a sequence header or without a coded frame is
`missing_structure`, and a coded frame before the first sequence header is `out_of_order`. Other
OBUs, those of reserved types among them, are passed over (§6.3).

§14.3 **The sequence header.** The first sequence header OBU's payload, read to its cropping
window: `seq_header_id` uvlc() (16 or more is `reserved_value`), `seq_profile_idc` u(5) (5 to
30 are reserved, Table A.1: `reserved_value`), `single_picture_header_flag` u(1),
`seq_level_idx` u(5) (22 to 30 are reserved, Table A.7: `reserved_value`), `seq_tier` u(1) where
`seq_level_idx` is above 3 and the flag is 0 (else 0), `chroma_format_idc` uvlc() (above 3:
`reserved_value`) and `bit_depth_idc` uvlc() (above 1: `reserved_value`). A chroma format the
profile does not admit is `reserved_value` (Table A.1: profiles 0 to 2 admit 4:0:0 and 4:2:0, 3
also 4:2:2, 4 also 4:4:4, 31 each). Then, unless the flag is 1, `seq_lcr_id` u(3),
`still_picture` u(1), `max_tlayer_id` u(2), `max_mlayer_id` u(3), where that is above 0
`seq_max_mlayer_cnt_minus_1` u(CeilLog2(`max_mlayer_id` + 1)) (above `max_mlayer_id`:
`reserved_value`), and `monotonic_output_order_flag` u(1); then `frame_width_bits_minus_1` u(4),
`frame_height_bits_minus_1` u(4), `max_frame_width_minus_1` and `max_frame_height_minus_1` in
those widths plus one, and `seq_cropping_window_present_flag` with, when set, four uvlc()
offsets: left, right, top and bottom. An offset above the size less one, or a window that
leaves no sample (left + right at least the width, or top + bottom at least the height), is
`reserved_value`. A uvlc() of 32 or more leading zero bits is `reserved_value` (§4.11.3).
Reading past the OBU's length is `length_mismatch`. The probe does not read the rest of the
header, `film_grain_params_present` among it.

§14.4 **Parameters.** `seq_header_id`; `profile` (`seq_profile_idc`); `level_idx` and `level`
(Table A.7's name, `"maximum"` for 31); `tier`; `single_picture_header`; `still_picture` (true
under that flag, else the bit read); `chroma_format_idc`, `monochrome` and `subsampling` (`[SubsamplingX,
SubsamplingY]`, Table 6.2); `bit_depth` (10 for `bit_depth_idc` 0, 8 for 1, Table 6.3);
`max_size` (`[max_frame_width_minus_1 + 1, max_frame_height_minus_1 + 1]`); `cropped` (that size
less the window, which §6.4.1 states for a frame of the maximum size); `max_tlayer_id`,
`max_mlayer_id`, `mlayers` (`SeqMaxMlayerCnt`); the counts `temporal_units`, `frames` and
`obus`; and `codec`.

§14.5 **No codec string.** `codec` is `null`. AOMedia has released no AV2 binding to ISO BMFF:
the AV2 Codec ISO Media File Format Binding is a working draft, which on 10 November 2026 said
it is not to be referenced other than as a working draft; its string, a sample entry code and
one character each for the profile, the level and the tier, had changes to it open that day.
The WebCodecs Codec Registry lists no AV2 string either, so browser-sink §4.2's gate refuses
any (`codec_unregistered`) and no user agent is asked about an AV2 payload
([platform-decode](platform-decode.md) §2.5). An AV2 payload routes to a sink-supplied decoder:
a host or wasm decoder the page holds (browser-sink §4.3 steps 5 and 6), or a native sink's own.

## 15. AC-4

§15.1 **Sources.** ETSI TS 103 190-1 V1.4.1: `variable_bits()` (§4.2.2), `ac4_toc()` and
`ac4_presentation_info()` (§4.2.3.1, §4.2.3.2), `presentation_version()` (Table 6), the sampling
frequency and frame rate (§4.3.3.2.5, §4.3.3.2.6, Tables 82 to 84) and the sync frame (Annex G);
ETSI TS 103 190-2 V1.3.1: `ac4_toc()` and `ac4_presentation_v1_info()` (§6.2.1.1, §6.2.1.3),
the bitstream versions (§6.3.2.1.1), the combinations of bitstream version, presentation version
and `presentation_config` (§4.6, Table 4), the decoder-specific information's fields (Table E.6)
and the codecs parameter (§E.13).

§15.2 **Frames.** A `wai.audio.ac4` payload is AC-4 sync frames back to back (TS 103 190-1
Annex G: the frames of the media type `audio/ac4`). Its first two bytes are a `sync_word`,
`0xAC40` or `0xAC41`; otherwise `no_signature`. Each frame is a `sync_word` (a later frame's
that is neither value is `reserved_value`), `frame_size` (16 bits, or `0xFFFF` and then 24
bits), that many bytes of `raw_ac4_frame()`, and after `0xAC41` a `crc_word`: the CRC of §G.4.2
(polynomial x^16 + x^15 + x^2 + 1, initial state 0, no reflection, no final XOR) over
`frame_size`, the raw frame and `crc_word` is 0, else `reserved_value`. A frame past the
payload's end is `truncated`.

§15.3 **The table of contents.** The first frame's `ac4_toc()`, read to the first
presentation's `md_compat`: `bitstream_version` u(2), with `variable_bits(2)` added when it is 3
(a version above 2, which TS 103 190-2 does not decode, is `outside_probe`); `sequence_counter`
u(10); `b_wait_frames` and, when set, `wait_frames` u(3) and, when that is above 0, two bits;
`fs_index` u(1) (44.1 kHz for 0, 48 kHz for 1); `frame_rate_index` u(4) (14 and 15 are
reserved, and at 44.1 kHz every index but 13: `reserved_value`); `b_iframe_global`;
`b_single_presentation` for one presentation, else `b_more_presentations` and
`variable_bits(2)` + 2 presentations, or none; `b_payload_base` and, when set,
`payload_base_minus1` u(5) and for 31 `variable_bits(3)`; for bitstream version 2,
`b_program_id` and, when set, `short_program_id` u(16), `b_program_uuid_present` and a 128-bit
UUID. Then, where there is a presentation: its substream flag (`b_single_substream`, or for
version 2 `b_single_substream_group`), when that is 0 `presentation_config` u(3) with
`variable_bits(2)` added at 7, `presentation_version()` (ones counted to a zero; above 2 is
`reserved_value`), and `md_compat` u(3) unless `presentation_config` is 6. The versions combine
as Table 4 allows, else `reserved_value`: bitstream version 0 with presentation version 0, 1 with
0, 1 with 1 and then `presentation_config` 7, and 2 with 1 or 2; under every other allowed pair
a `presentation_config` above 6 is `reserved_value`. A `variable_bits()` value past 2^32 is
`outside_probe`. Reading past the frame's raw bytes is `length_mismatch`. The probe reads no other
presentation and no substream.

§15.4 **Parameters.** `bitstream_version`, `sequence_counter`, `wait_frames` (or `null`),
`sampling_rate`, `frame_rate_index`, `frame_rate` (`[numerator, denominator]`, in lowest terms:
24000/1001, 24, 25, 30000/1001, 30, 48000/1001, 48, 50, 60000/1001, 60, 100, 120000/1001 and 120
for 0 to 12, and for 13 48000/2048 at 48 kHz and 44100/2048 at 44.1 kHz), `frame_length`
(`frame_len_base`), `iframe_global`, `presentations` (`n_presentations`), `program_id` (or
`null`), `presentation` (the first: `config`, `version` and `md_compat`; `null` where there is
none), `codec`, and the counts `frames` and `crc_frames`.

§15.5 **The codec string.** TS 103 190-2 §E.13: `ac-4.`, then `bitstream_version`,
`presentation_version` and `md_compat` as two hexadecimal digits each, dot-separated. The
decoder-specific information they are read from copies them from the table of contents (Table
E.6), and the probe takes them from the first presentation. `ac-4.02.01.03` is §E.13's example
and `ac-4.00.00.03` TS 103 190-1 §F.1.1's; the corpus holds both. `codec` is `null` where there
is no presentation or the first has no `md_compat`. A stream of several presentations has a
string for each; the probe gives the first's.

## 16. IAMF

§16.1 **Sources.** Immersive Audio Model and Formats v2.0.0 (24 August 2026): the OBU syntax and
header (§3.1, §3.2), the IA Sequence Header (§3.4), the Codec Config OBU (§3.5) and the
codec-specific configurations (§3.13), the Audio Element OBU's first fields (§3.6), the Audio
Frame OBU (§3.10), the profiles (§4), the standalone IA Sequence (§5), the codecs parameter
(§6.4) and `leb128()` (§8.1.1); RFC 7845 §5.1 for the Opus configuration, and RFC 9639 §8.2
and §9.1.2 for the FLAC one. An `mp4a` configuration is a DecoderConfigDescriptor of ISO/IEC
14496-1, which is not openly readable: the probe does not read it.

§16.2 **OBUs.** A `wai.audio.iamf` payload is a standalone IA Sequence (§5), or several back to
back: OBUs, each a header byte (`obu_type` 5 bits, `obu_redundant_copy`, a bit whose meaning the
type gives, `obu_extension_flag`), `obu_size` as a `leb128()` (as §14.2's), then that many
bytes: for an audio frame (types 5 to 23) whose bit is set, two `leb128()` trimming counts; with
the extension flag, `extension_header_size` and that many bytes; then the payload. The first OBU
is an IA Sequence Header (type 31) whose payload begins with the `ia_code` `iamf`; otherwise
`no_signature`. An OBU past the payload's end is `truncated`, and a field past its `obu_size` is
`length_mismatch`. The type's bit set where the type does not name it (every type but 2, 4 and 5
to 23, for which it is `reserved`, 0), and `obu_redundant_copy` set on a temporal delimiter or an
audio frame, are `reserved_value`.

§16.3 **The Descriptors.** The sequence header's payload is the `ia_code`, `primary_profile`
u(8) and `additional_profile` u(8); a primary profile above 5 is `reserved_value` (6 to 255 are
reserved for future profiles; an additional profile may name one, and is not checked). The IA
Data begins at the first parameter block, temporal delimiter or audio frame (types 3, 4 and 5 to
23); the OBUs before it are the first set of Descriptors (§5.1.1). Where there is IA Data and no
mix presentation (type 2) before it, the payload is `out_of_order` if a mix presentation comes
later and `missing_structure` if none does. Among the Descriptors come codec configurations
(type 0), then audio elements (1), then mix presentations (2): one of these after a later kind
is `out_of_order`. Metadata, reserved OBUs and copies of the sequence header are passed over. A
set without a codec configuration, an audio element or a mix presentation is
`missing_structure`, and so is an audio element whose `codec_config_id` no codec configuration of
the set has.

§16.4 **Codec configurations.** `codec_config_id` leb128(), `codec_id` (four bytes),
`num_samples_per_frame` leb128() (0 is `reserved_value`), `audio_roll_distance` (a signed 16-bit
value), then `decoder_config`. A `codec_id` other than `Opus`, `mp4a`, `fLaC` and `ipcm` is
`outside_probe` (§3.5: a later version may add codecs). The roll distance is −⌈3840 ÷
`num_samples_per_frame`⌉ for Opus, −1 for `mp4a` and 0 for `fLaC` and `ipcm`, else
`reserved_value`. For Opus, `decoder_config` is RFC 7845's identification header without its
magic signature, big-endian: version (8 bits), output channel count (8), pre-skip (16), input
sample rate (32), output gain (16), channel mapping family (8); a channel count other than 2, a
gain other than 0 or a family other than 0 is `reserved_value` (§3.13.1). For FLAC it is metadata
blocks, each a last-block flag, a 7-bit type and a 24-bit length, read to the one whose flag is
set; the first is a STREAMINFO block (type 0, length 34) whose minimum and maximum block sizes
are `num_samples_per_frame`, whose sample rate is one of those of RFC 9639's codes 0b0001 to
0b1011 (8000, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400 and 192000), with
two channels and 16, 24 or 32 bits per sample; anything else is `reserved_value` (§3.13.3). For
LPCM it is `sample_format_flags` (0 or 1), `sample_size` (16, 24 or 32) and `sample_rate` (16000,
32000, 44100, 48000 or 96000), in 8, 8 and 32 bits, else `reserved_value` (§3.13.4). §4 allows at
most two codec configurations, and of two, one is `ipcm`; otherwise `reserved_value`.

§16.5 **Audio elements and IA Data.** An audio element's `audio_element_id`, its type (the top
three bits of the next byte: 0 channel-based, 1 scene-based, 2 object-based; 3 to 7, whose
syntax a later version would give, are `outside_probe`), `codec_config_id`, `num_substreams` (0
is `reserved_value`) and the substream ids; the probe reads no further. In the IA Data, an audio
frame of type 5 states its substream id, which is above 17, else `reserved_value` (§3.10). A
non-redundant sequence header there begins a further IA Sequence (§5.2), whose Descriptors the
probe passes over. A payload with no audio frame is `missing_structure`.

§16.6 **Parameters.** `primary_profile`, `additional_profile`, `codec_configs` (each `id`,
`codec_id`, `samples_per_frame`, `roll_distance`, `sample_rate` and `bit_depth`: for Opus the
rate is 48000, §3.13.1's, and the depth `null`; for `mp4a` both are `null`), `audio_elements`
(each `id`, `type`, `codec_config_id` and `substreams`), `mix_presentations`, the counts
`temporal_units`, `audio_frames`, `parameter_blocks` and `sequences`, and `codec`.

§16.7 **The codec string.** §6.4: `iamf.`, the primary and the additional profile as three
decimal digits each, then the elements of the codec's own string: `Opus`, `mp4a.40.2` (AAC-LC,
the only object type §3.13.2 allows), `fLaC` or `ipcm`. Of two codec configurations, one of them
LPCM, the string names the other, as §4.4's example `iamf.003.003.Opus` names Opus beside LPCM,
and names `ipcm` where both are. The corpus holds that example.

## 17. IVAS

§17.1 **Sources.** 3GPP TS 26.253 V19.3.0: the IVAS payload of its RTP payload format (Annex
A.3.3: the payload header and its ToC and E bytes, the frame sizes of Table A.3.3.1-1, the bit
rates of Table A.3.3.3.2-1, the frame data, the processing information) and the IVAS format a
frame signals in its first bits (§5.1, Tables 5.11 and 5.12); 3GPP TS 26.445 V19.1.0 Annex
A.2.2 for the EVS frame types a ToC byte can also name (Tables A.4 and A.5); 3GPP TS 26.244
V19.1.0 for the 3GP sample entry `sivs` and its codecs parameter (§6.15 to §6.17, Annex A.2.2).

§17.2 **The payload.** A `wai.audio.ivas` payload is one IVAS payload as TS 26.253 §A.3.3.2
lays it out, without an RTP header: the payload header, the frame data of each frame it
describes (any number of frames), and then processing information where an E byte announces it,
or zero padding. It has no signature: the probe reads a payload declared to be one and never
refuses `no_signature`.

§17.3 **The header.** Bytes, each with its top bit `H` 1 for an E byte and 0 for a ToC byte,
ending at the first ToC byte whose second bit `F` is 0; bytes that end before it are
`truncated`. An E byte first is the CMR (§A.3.3.3.3.2). A later E byte's next three bits are its
type `ET` (§A.3.3.3.3.3): `001` with its bit `S` set is followed by a subformat byte, which is
part of the header; `010` announces processing information; `100` to `111` are reserved for
future use, and the bytes after one, up to the next ToC byte, are passed over. A ToC byte's low
six bits are the EVS mode bit, the IVAS indicator and a 4-bit `BR`; with the mode bit 0, the
indicator 1 and `BR` `1110` (split rendering) an SR-ToC byte follows it. Each ToC byte describes
a frame, in order:

- mode bit 0, indicator 1: IVAS at `BR`'s rate (13.2, 16.4, 24.4, 32, 48, 64, 80, 96, 128, 160,
  192, 256, 384 and 512 kbps for 0 to 13), or the 5.2 kbps SID frame for `1111`; `1110`, split
  rendering, is `outside_probe`, since its frames' sizes are set by TS 26.253 §7.6, which the
  probe does not read;
- mode bit 0, indicator 0: EVS Primary (TS 26.445 Table A.4: 2.8, 7.2, 8.0, 9.6, 13.2, 16.4,
  24.4, 32, 48, 64, 96 and 128 kbps for 0 to 11, the 2.4 kbps SID frame for `1100`); `1101`, for
  future use, is `reserved_value`;
- mode bit 1: EVS AMR-WB IO (Table A.5): `1010` to `1101`, for future use, are
  `reserved_value`, and `0000` to `1001` are `outside_probe`, since their frame sizes are TS
  26.201's, which was not read;
- `1110` (SPEECH_LOST) and `1111` (NO_DATA) of the EVS modes are frames with no data.

An IVAS or EVS frame is 20 ms at its rate: rate × 20 ms ÷ 8 bytes (Table A.3.3.1-1: 264 bits
at 13.2 kbps, 104 for the SID frame). Frame data past the payload's end is `truncated`. After
the last frame, where an E byte announced processing information, at least one byte follows
(else `missing_structure`), and the probe does not read them; otherwise the bytes left are zero
padding, and one that is not zero is `trailing_bytes`.

§17.4 **The IVAS format.** The first IVAS frame's first bits state its format (TS 26.253 §5.1).
An active frame: `00` STEREO and `01` MC; below 24.4 kbps `10` ISM; from 24.4 kbps `100` ISM,
`1010` OMASA and `1011` OSBA; `110` SBA and `111` MASA. Table 5.11 gives OSBA below 24.4 kbps
the bits of SBA, and OMASA in its Rend mode those of MASA, and a field later in the frame, which
the probe does not read, tells them apart: the probe reports `SBA` and `MASA` for those bits. A
SID frame (Table 5.12): three bits, 0 and 1 STEREO, 2 ISM, 3 and 7 MASA, 5 and 6 SBA; 4 is
`reserved_value`.

§17.5 **Parameters.** `cmr` (the CMR's `T` field and its last four bits, `{t, value}`, or
`null`), `e_bytes` (the E bytes after it), `pi_data`, `frames` (each `mode`: `ivas`, `evs`,
`speech_lost` or `no_data`; `bitrate` in bit/s, or `null`; `sid`; `bytes`), `format` (§17.4, or
`null` where there is no IVAS frame), `pi_bytes`, `padding_bytes` and `codec`.

§17.6 **The codec string.** TS 26.244 Annex A.2.2: `sivs`, the 3GP sample entry of IVAS
(§6.15), with no other element. The annex's ABNF line for `iso-ivas` repeats the octets of
`sevs`; its comment and its prose name `sivs`, which is what the probe gives. A 3GP file states
the coded format and the IVAS version in the sample entry's boxes `ivcf` and `iver` (§6.16,
§6.17), which an IVAS payload does not carry.

## 18. EVC: no probe

§18.1 `wai.video.evc` and `wai.video.evc.baseline` have no probe. Their payload is the raw
bitstream format of ISO/IEC 23094-1 Annex B (SPEC §5), and that format's layout, the NAL unit
types and the sequence parameter set that states the profile, level and toolset are in ISO/IEC
23094-1, which is not openly readable; the binding to ISO BMFF and its codecs parameter are in
ISO/IEC 14496-15, which is not either. The openly readable text, RFC 9584 (the RTP payload
format for EVC), gives the two-byte NAL unit header (§1.1.4: `forbidden_zero_bit`,
`nal_unit_type_plus1` 6 bits, `nuh_temporal_id` 3, `nuh_reserved_zero_5bits` 5,
`nuh_extension_flag` 1; types up to 23 are VCL, and type 1 is IDR) and says that its
`profile-id` and `level-id` are read from the SPS's `profile_idc` and `level_idc`, `level-id` 90
being level 3 (§7.2). It does not say how NAL units are delimited in the Annex B format, nor
where in the SPS those fields lie, so no probe can be written from it: one that guessed the
framing would accept or refuse payloads on the guess. No codec string is given, and
browser-sink §4.2's gate refuses any EVC string.

## 19. Coding for machines: no probe

§19.1 `wai.video.vcm` and `wai.tensor.fcm` are candidates (SPEC §5) and have no probe. They are
registered for video coding for machines, ISO/IEC 23888-2, and feature coding for machines,
ISO/IEC 23888-4, the second and fourth parts of the standard its committee calls MPEG-AI.
Neither part is published, and neither's text is openly readable.

§19.2 **What was read.** The committee's public project pages for the two parts, as served on
10 November 2026. Each gives the part's first edition a publication year of 0 and the status
`ongoing`, and its objectives: for Part 2, to "define bitstream syntax and semantics of encoded
video, decoding procedure to reconstruct video as well as descriptors extracted from video that
are efficient in terms of bitrate and performance of machine tasks after decoding"; for Part 4,
to "define bitstream syntax and semantics for compressed intermediate features that are
efficient in terms of bitrate and enable connecting two parts of a machine vision task network
without significantly reducing the quality of result of the machine vision task network". The
only documents either page lists are the common test conditions of each meeting (for Part 4,
the common test and training conditions), which state how proposals are compared and give no
syntax.

§19.3 **What follows.** No text read says how either bitstream begins, how its units are
delimited, or where a header states a profile, a level, a picture size, a cut point or a tensor's
shape. A probe that guessed any of them would accept or refuse payloads on the guess, so none is
written: `probe` gives `no_probe` for both capabilities, whatever the bytes, and the corpus
states that outcome for each (`gen/other/vcm_has_no_probe.bin`, `gen/other/fcm_has_no_probe.bin`,
fixed filler, since no layout is known to write). No codec string is given. The reference
software of either part was not read as a specification: a draft's software writes that draft's
bitstream, which the next meeting may change, as §10 found of another working draft.

§19.4 A revision that pins either candidate reads the published part, states the payload format
in SPEC §5 and gives the capability its probe here. Until then an encoder emits neither and a
sink dispatches neither (SPEC §5, *Candidate capabilities*). What the registrations do state is
what each bitstream is for, which a decoder's output cannot show: a `wai.video.vcm` payload is
coded for a task's result, and a claim about that result is a [task-fidelity](task-fidelity.md)
claim; a `wai.tensor.fcm` payload is one side of a network cut in two, and the work of its two
sides is stated by a pair of `split-computation` claims (task-fidelity §5).