v0.6.0

• New parsers: JPEG/JFIF, LCEVC, Theora, Opus, Vorbis, USAC/xHE-AAC, OGG, VOB
• New metadata parsers: GoPro GPMF, DJI metadata, generic KLV, SMPTE 2038, SMPTE RDD-11, Teletext subtitles, DVD VOB subtitles, event messages (SCTE/ID3), ITU-T T.35 metadata
• MXF: detection upgraded to full parsing (partitions, KLV essence, metadata)
• MPEG Program Stream: detection upgraded to full parsing (pack header, system header, PSM)
• FLV: parse AVC Decoder Configuration Record (SPS/PPS), broader tag-type and script-data coverage
• AC-3/E-AC-3: full mixing metadata, information metadata, extended mix data
• AVS: distinguish AVS2 and AVS3
• MP4: hardened fragmented MP4 (DASH/CMAF) with cross-segment state propagation
• DASH/HLS: analyze segmented streams as a single session with lazy segment loading
• New WebGL-accelerated YUV viewer with automatic format detection and component correlation analysis

More detail on each, below.

Files we used to recognize, we now actually open

Two formats made the jump from "detected" to fully parsed:

• MXF: partitions, KLV essence, and metadata are now inspectable down to the field level. If you work with mezzanine files or broadcast archives, opening an MXF in the analyzer is finally a useful starting point rather than a dead end.
• MPEG Program Stream (PS): pack headers, system headers, and Program Stream Maps. PS is the container used in DVDs and many legacy broadcast workflows, and it was a long-standing blind spot.

How to use it: just open the file the way you always have. Drop your MXF or .vob/.mpg into the analyzer and the header tree will populate with real fields, not just "MXF file detected".

New parsers worth knowing about

We added parsers for a broad set of codecs and metadata formats. The headlines:

• Opus: full RFC 6716 packet parsing, container-aware across MKV, MP4, and MPEG-TS. Useful for sanity-checking WebRTC captures and modern streaming audio.
• JPEG / JFIF: markers, EXIF, and full coverage of baseline, progressive, lossless, and arithmetic-coded variants.
• OGG + Vorbis + Theora: combined, these give us full coverage of typical Ogg payloads, including multiplexed streams.
• LCEVC: Low Complexity Enhancement Video Codec, layered on AVC or HEVC.
• USAC / xHE-AAC: Unified Speech and Audio Coding.

On the metadata side, two additions stand out:

• GoPro GPMF: accelerometer, gyroscope, and GPS telemetry embedded in GoPro MP4 files. If you've ever wondered what the gpmd track contains, you can now see it parsed.
• DJI metadata: drone telemetry and sensor data.

Plus broadcast-flavored additions: SMPTE 2038, SMPTE RDD-11, Teletext and DVD VOB subtitles, and generic KLV, event messages (SCTE / ID3), and ITU-T T.35 registrations.

Deeper parsing for formats you already used

A few formats were supported, but only partly. They now go much further:

• FLV: extracts the AVC Decoder Configuration Record (SPS / PPS from the embedded H.264 stream), with broader tag-type and script-data coverage. Useful when debugging legacy live streams or screen-recording outputs.
• AC-3 / E-AC-3: full E-AC-3 mixing metadata, information metadata, and extended mix data. Professional broadcast workflows depend on these fields to drive downmix and loudness behavior.
• AVS: proper distinction between AVS2 and AVS3.
• MP4: hardened fragmented-MP4 support, with explicit fragment handling and cross-segment state propagation. This is also what makes the new multi-segment streaming experience reliable.

More ways to open files

The Open File dialog has three new modes that change how you start an analysis session.

Multiple files as one stream. The Advanced tab accepts a set of related files and treats them as a single coherent stream. The init segment's track tables, decoder configs, and fragment timelines flow through every media segment that follows. Select the init segment and the media segments together. The analyzer sorts them automatically by filename; drag to reorder if it gets it wrong, and segments load lazily so very large streams open instantly.

What this unlocks in practice:

• End-to-end DASH / HLS / CMAF sessions. Inspect an init segment plus its media segments together, instead of losing parser state every time you open the next file.
• Init + media compatibility checks. Confirm a CMAF init actually covers what the TFHD / TFRA fields in the media segments expect. Mismatches show up as parser warnings on the first media segment, not as a vague "didn't decode" downstream.
• Locating a glitch around a segment boundary. Capture the segments around a discontinuity, drop them in together, and step the packet view across the boundary to see exactly which field changed.
• Ad-insertion handoffs in context. Pre-ad + ad + post-ad in one session lets you check SCTE-35 markers, PTS jumps, and PSSH transitions as a continuous timeline.
• Inspecting live captures. Drop a directory of .ts chunks captured from a live feed and walk them as one continuous stream, with PCR continuity, PAT/PMT version bumps, and PSI versioning all visible end-to-end.
• Inspecting fragmented MP4 across moof boundaries. With the hardened fMP4 fragment handling, decoder configs and sample tables carry from one fragment to the next so the packet stream stays coherent.

Open from a URL. The URL tab points the analyzer at a remote file instead of uploading a local copy — handy for inspecting CDN responses directly, or when the asset is too large to be practical to download. The server needs CORS enabled and a Content-Length header so the analyzer can seek; without seeking, only the beginning of the file is inspectable.

Force a specific parser. The Advanced tab also includes a Parser Selection dropdown that overrides automatic detection. Useful when an input shares magic bytes with another format, when you have a headerless elementary stream that auto-detection hesitates on, or when you want to see what a specific parser makes of a malformed file. Leave it on "auto" for the common case.

The new YUV viewer

Raw YUV files are notoriously hard to inspect. They carry no width, height, or pixel-format metadata. The new YUV viewer fixes that:

• WebGL-accelerated decoding: frames render on the GPU, so even 4K YUV scrubs smoothly in the browser.
• Automatic format detection: the viewer tries to infer dimensions and pixel format from file size and content.
• Color-component correlation analysis: useful for diagnosing chroma subsampling and bit-depth mismatches.

How to use it: pick YUV Viewer from the app switcher in the header, drop in a raw YUV file, and let the viewer guess the format. If it gets it wrong, adjust dimensions and pixel format in the side panel and the preview updates live.