std.video — Video-Metadaten

Das std.video-Paket liest Video-Container-Metadaten (Auflösung, Dauer, FPS, Codec) aus AVI- und MP4/ISOBMFF-Dateien. AVI-Dateien mit MJPEG-Codec unterstützen zusätzlich Frame-Extraktion und Dekodierung.

Es gibt kein vollständiges Videodecoding (keine Softdecoder für H.264/H.265/AV1) — die Units sind auf Metadaten-Extraktion und MJPEG-Einzelbilder ausgelegt.

→ Units-Übersicht · Lyx-Sprache

VidMeta ist ein 64-Byte-Puffer im Heap. Alle Felder sind int64 (8 Bytes). Die Funktionen AviMeta, AviMetaFile, Mp4Meta und Mp4MetaFile schreiben direkt in diesen Puffer:

FPS wird als Bruch dargestellt: FPS = VID_OFF_FPS_NUM / VID_OFF_FPS_DEN. Bei MP4 sind beide Felder nicht aus dem moov-Box ableitbar und werden auf 0/1 gesetzt.

import std.video.core;
import std.video.mp4;
import std.alloc;
import std.io;

fn main(): int64 {
    var vid: int64 := alloc(VID_SIZE);

    var ok: int64 := Mp4MetaFile("film.mp4"c as int64, 0, vid);
    if (ok == 0) { PrintLn("Fehler"); return 1; }

    var w:   int64 := peek64(vid + VID_OFF_WIDTH);
    var h:   int64 := peek64(vid + VID_OFF_HEIGHT);
    var dur: int64 := peek64(vid + VID_OFF_DURATION_MS);
    var cod: int64 := peek64(vid + VID_OFF_CODEC);

    PrintLn(IntToStr(w) + "x" + IntToStr(h) + "  " + IntToStr(dur / 1000) + "s");

    if (cod == VID_CODEC_H264) { PrintLn("Codec: H.264"); }
    if (cod == VID_CODEC_H265) { PrintLn("Codec: H.265"); }
    if (cod == VID_CODEC_AV1)  { PrintLn("Codec: AV1");  }

    free(vid, VID_SIZE);
    return 0;
}

// Mindestens 12 Bytes erforderlich.
// Gibt VID_FMT_* zurück.
var fmt: int64 := VidDetectFormat(buf, len);
if (fmt == VID_FMT_AVI) { AviMeta(buf, len, vid); }
if (fmt == VID_FMT_MP4) { Mp4Meta(buf, len, vid); }

import std.video.avi;

// Aus Speicher-Puffer
var ok: int64 := AviMeta(buf, len, vid);    // 1 = Erfolg, 0 = Fehler

// Aus Datei (liest automatisch in Puffer)
// plen: Zeiger auf int64 → erhält Dateigröße; oder 0
var ok: int64 := AviMetaFile("clip.avi"c as int64, 0, vid);

AVI liefert alle Felder einschließlich FPS (aus strh.dwRate/dwScale) und Frame-Zählung (aus avih.dwTotalFrames).

// Anzahl '00dc'-Chunks (Video-Stream 0) in der movi-Liste
var count: int64 := AviGetFrameCount(buf, len);

// Zeiger auf Frame-Daten (innerhalb von buf), Größe in pFrameLen
// frameIdx: 0-basiert
var pFrameLen: int64 := alloc(8);
var framePtr: int64 := AviGetFrameOffset(buf, len, 0, pFrameLen);
var frameLen: int64 := peek64(pFrameLen);

AviExtractMjpegFrame kombiniert Frame-Suche und JPEG-Dekodierung in einem Schritt. Nur bei VID_CODEC_MJPEG sinnvoll:

import std.video.avi;
import std.image.core;

fn ExtractFrame(buf: int64, len: int64, frameIdx: int64): int64 {
    var img: int64 := GrfImageAlloc(0, 0);   // Größe wird vom Decoder gesetzt
    var ok: int64 := AviExtractMjpegFrame(buf, len, frameIdx, img);
    if (ok == 0) { GrfImageFree(img); return 0; }
    return img;   // GrfImage mit RGBA-Pixeln; Aufrufer muss GrfImageFree aufrufen
}

import std.video.mp4;

// Aus Speicher-Puffer (erfordert 'ftyp'-Box ab Offset 4)
var ok: int64 := Mp4Meta(buf, len, vid);

// Aus Datei
var ok: int64 := Mp4MetaFile("film.mp4"c as int64, 0, vid);

Der Reader traversiert moov → mvhd (Dauer, Timescale), moov → trak → tkhd (Auflösung), mdia → hdlr ('vide'-Track), minf → stbl → stsd (Codec-Erkennung).

Einschränkungen MP4: FPS und Frame-Zählung sind aus dem moov-Box allein nicht zuverlässig ermittelbar und werden auf VID_OFF_FPS_NUM=0, VID_OFF_FPS_DEN=1, VID_OFF_FRAME_COUNT=0 gesetzt. Dauer und Auflösung sind immer verfügbar.

Aus der stsd-Box (minf → stbl → stsd):

Aus dem strh.fccHandler-Feld des Video-Streams:

Letzte Aktualisierung: 2026-06-15