Was ist der richtige Weg, um Keyframes in FFmpeg für DASH zu reparieren?

TL; DR

Ich würde folgendes empfehlen:

• libx264: -g X -keyint_min X (und optional -force_key_frames "expr:gte(t,n_forced*N)" hinzufügen)
• libx265: -x265-params "keyint=X:min-keyint=X"
• libvpx-vp9: -g X

dabei ist X das Intervall in Frames und N das Intervall in Sekunden. Beispiel: Für ein 2-Sekunden-Intervall mit einem 30-fps-Video ist X = 60 und N = 2.

Ein Hinweis zu verschiedenen Rahmentypen

Um dieses Thema richtig zu erklären, müssen wir zuerst die beiden Arten von I-Frames/Keyframes definieren:

• IDR-Frames (Instantaneous Decoder Refresh): Ermöglichen das unabhängige Decodieren der folgenden Frames, ohne auf Frames vor dem IDR-Frame zuzugreifen.
• Non-IDR-Frames: Diese benötigen einen vorherigen IDR-Frame, damit die Dekodierung funktioniert. Nicht-IDR-Frames können für Szenenschnitte in der Mitte einer GOP (Gruppe von Bildern) verwendet werden.

Was wird für das Streaming empfohlen?

Für den Streaming-Fall möchten Sie:

• Stellen Sie sicher, dass sich alle IDR-Frames an regulären Positionen befinden (z. B. bei 2, 4, 6,… Sekunden), damit das Video in gleich lange Segmente aufgeteilt werden kann.
• Aktivieren Sie die Szenenschnitterkennung, um die Codierungseffizienzqualität zu verbessern. Dies bedeutet, dass I-Frames zwischen IDR-Frames platziert werden können. Sie können weiterhin mit deaktivierter Szenenschnitterkennung arbeiten (und dies ist immer noch Teil vieler Anleitungen), dies ist jedoch nicht erforderlich.

Was machen die Parameter?

Um den Encoder konfigurieren zu können, müssen wir verstehen, was die Keyframe-Parameter bewirken. Ich habe einige Tests durchgeführt und Folgendes für die drei Encoder libx264, libx265 und libvpx-vp9 in FFmpeg entdeckt:

• libx264:

  • -g legt das Keyframe-Intervall fest.
  • -keyint_min legt das minimale Keyframe-Intervall fest.
  • -x264-params "keyint=x:min-keyint=y" ist dasselbe wie -g x -keyint_min y.

  • / - Hinweis: Wenn beide auf den gleichen Wert gesetzt werden, wird das Minimum intern auf halb das maximale Intervall plus eins gesetzt, wie im Code x264 zu sehen ist:

    h->param.i_keyint_min = x264_clip3( h->param.i_keyint_min, 1, h->param.i_keyint_max/2+1 );
    

• libx265:

  • -g ist nicht implementiert.
  • -x265-params "keyint=x:min-keyint=y" funktioniert.

• libvpx-vp9:

  • -g legt das Keyframe-Intervall fest.
  • -keyint_min legt das minimale Keyframe-Intervall fest

  • Hinweis: Aufgrund der Funktionsweise von FFmpeg wird -keyint_min nur an den Encoder weitergeleitet, wenn er mit -g identisch ist. Im Code von libvpxenc.c in FFmpeg finden wir:

    if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
        enccfg.kf_min_dist = avctx->keyint_min;
    if (avctx->gop_size >= 0)
        enccfg.kf_max_dist = avctx->gop_size;
    

    Dies kann ein Fehler sein (oder ein Mangel an Funktionen?), Da libvpx definitiv das Festlegen eines anderen Werts für kf_min_dist unterstützt.

Solltest du -force_key_frames verwenden?

Mit der Option -force_key_frames werden im angegebenen Intervall (Ausdruck) zwangsweise Keyframes eingefügt. Dies funktioniert bei allen Encodern, kann jedoch zu Problemen mit der Geschwindigkeitskontrolle führen. Insbesondere bei VP9 sind mir starke Qualitätsschwankungen aufgefallen, daher kann ich die Verwendung in diesem Fall nicht empfehlen.

Hier sind meine fünfzig Cent für den Fall.

Methode 1:

mit den Argumenten von libx264 herumspielen

-c: v libx264 -x264opts keyint = GOPSIZE: min-keyint = GOPSIZE: scenecut = -1

Generieren Sie iframes nur in den gewünschten Intervallen.

Beispiel 1:

ffmpeg -i test.mp4 -codec:v libx264 \
-r 23.976 \
-x264opts "keyint=48:min-keyint=48:no-scenecut" \
-c:a copy \
-y test_keyint_48.mp4

Generiere iframes wie erwartet so:

Iframes     Seconds
1           0
49          2
97          4
145         6
193         8
241         10
289         12
337         14
385         16
433         18
481         20
529         22
577         24
625         26
673         28
721         30
769         32
817         34
865         36
913         38
961         40
1009        42
1057        44
1105        46
1153        48
1201        50
1249        52
1297        54
1345        56
1393        58

Methode 2 wird abgeschrieben. Weggelassen

Methode 3:

füge alle N Sekunden einen Keyframe ein (MÖGLICHERWEISE):

-force_key_frames expr: gte (t, n_forced * GOP_LEN_IN_SECONDS)

Beispiel 2

ffmpeg -i test.mp4 -codec:v libx264 \
-r 23.976 \
-force_key_frames "expr:gte(t,n_forced*2)"
-c:a copy \
-y test_fkf_2.mp4

Generieren Sie ein iframes auf eine etwas andere Art:

Iframes     Seconds
1           0
49          2
97          4
145         6
193         8
241         10
289         12
337         14
385         16
433         18
481         20
519         21.58333333
529         22
577         24
625         26
673         28
721         30
769         32
817         34
865         36
913         38
931         38.75
941         39.16666667
961         40
1008        42
1056        44
1104        46
1152        48
1200        50
1248        52
1296        54
1305        54.375
1344        56
1367        56.95833333
1392        58
1430        59.58333333
1440        60
1475        61.45833333
1488        62
1536        64
1544        64.33333333
1584        66
1591        66.29166667
1632        68
1680        70
1728        72
1765        73.54166667
1776        74
1811        75.45833333
1824        75.95833333
1853        77.16666667
1872        77.95833333
1896        78.95833333
1920        79.95833333
1939        80.75
1968        81.95833333

Wie Sie sehen, werden alle 2 Sekunden IFrames UND auf Scenecut (Sekunden mit schwebendem Teil) platziert, was meiner Meinung nach für die Komplexität des Videostreams wichtig ist.

Genearated Dateigrößen sind ziemlich gleich. Sehr seltsam, dass selbst mit mehr Keyframes in Methode 3 manchmal weniger Dateien erzeugt werden als mit dem normalen x264-Bibliotheksalgorithmus.

Um mehrere Bitrate-Dateien für den HLS-Stream zu generieren, wählen wir Methode drei. Es ist perfekt ausgerichtet mit 2 Sekunden zwischen den Chunks, sie haben Iframe am Anfang jedes Chunks und sie haben zusätzliche Iframes in komplexen Szenen, was eine bessere Erfahrung für Benutzer bietet, die veraltete Geräte haben und keine x264-High-Profile wiedergeben können.

Hoffe es hilft jemandem.

Ich wollte ein paar Informationen hier hinzufügen, da meine googeln diese Diskussion ganz infos ein bisschen in meiner Suche zu finden nach oben gezogen zu versuchen, einen Weg zu segmentieren meine DASH kodiert, wie ich wollte, und keine der Informationen, die ich war völlig richtig gefunden zu finden.

Zuerst einige Missverständnisse, die beseitigt werden müssen:

1. Nicht alle I-Frames sind gleich. Es gibt große "I" -Frames und kleine "I" -Frames. Oder um die korrekte Terminologie zu verwenden, IDR-I-Frames und Nicht-IDR-I-Frames. IDR-I-Frames (manchmal als "Keyframes" bezeichnet) erzeugen eine neue GOP. Die Nicht-IDR-Frames werden nicht. Sie sind praktisch, um sich in einer GOP zu befinden, in der sich die Szene ändert.

2. -x264opts keyint=GOPSIZE:min-keyint=GOPSIZE ← Dies entspricht nicht Ihren Vorstellungen. Ich brauchte eine Weile, um das herauszufinden. Es stellt sich heraus, dass der min-keyint im Code begrenzt ist. Es darf nicht größer als (keyint / 2) + 1 sein. Wenn Sie diesen beiden Variablen denselben Wert zuweisen, wird der Wert für min-keyint beim Codieren um die Hälfte reduziert.

Hier ist die Sache: Szenenschnitt ist wirklich großartig, besonders in Videos mit schnellen harten Schnitten. Es bleibt schön und knackig, sodass ich es nicht deaktivieren möchte, aber gleichzeitig konnte ich keine feste GOP-Größe erhalten, solange es aktiviert war. Ich wollte den Szenenschnitt aktivieren, aber nur Nicht-IDR-I-Frames verwenden. Aber es hat nicht funktioniert. Bis ich (aus vielen Lektüren) herausgefunden habe, dass ich falsch gedacht habe # 2.

Es stellte sich heraus, dass ich keyint einstellen musste, um meine gewünschte GOP-Größe zu verdoppeln. Dies bedeutet, dass min-keyint kann meine gewünschten GOP-Größe eingestellt werden (ohne den internen Code in Halbschnitt), der Szene-Cut- Erkennungs verwenden IDR I-Frames innerhalb der GOP-Größe verhindert, weil der Rahmen seit dem letzten IDR zählt I-Frame ist immer kleiner als min-keyinit.

Und schließlich überschreibt das Setzen der Option force_key_frame die doppelte Größe keyint. Das funktioniert also so:

Ich bevorzuge Segmente in 2 Sekundenblöcken, daher ist meine GOPSIZE = Framerate * 2

ffmpeg <other_options> -force_key_frames "expr:eq(mod(n,<GOPSIZE>),0)" -x264opts rc-lookahead=<GOPSIZE>:keyint=<GOPSIZE * 2>:min-keyint=<GOPSIZE> <other_options>

Sie können mit ffprobe Folgendes überprüfen:

ffprobe <SRC_FLE> -select_streams v -show_frames -of csv -show_entries frame=coded_picture_number,key_frame,pict_type > frames.csv

In der generierten CSV-Datei wird in jeder Zeile Folgendes angegeben: frame, [is_an_IDR_?], [frame_type], [frame_number]:

frame,1,I,60  <-- frame 60, is I frame, 1 means is an IDR I-frame (aka KeyFrame)
frame,0,I,71  <-- frame 71, is I frame, 0 means not an IDR I_frame

Das Ergebnis ist, dass Sie IDR-I-Frames nur in festgelegten GOPSIZE-Intervallen sehen sollten, während alle anderen I-Frames Nicht-IDR-I-Frames sind, die bei Bedarf von der Szenenschnitterkennung eingefügt werden.

Es scheint, dass diese Syntax nicht immer funktioniert. Ich habe ziemlich viel auf unseren VOD-Inhalten sowie auf Live-Inhalten (Datei-Dumps) getestet und manchmal funktioniert scenecut nicht und löst einen Zwischen-Iframe aus:

Syntax für eine i50-> p50-Aufwärtskonvertierung, 2 Sek. Gop/Segment, IDR am Anfang, iFrames dazwischen, falls erforderlich

ffmpeg.exe -loglevel verbose -i avc_50i.ts -pix_fmt yuv420p -filter_complex yadif=1,scale=1920:1080 -vcodec libx264 -preset fast -x264-params "rc-lookahead=100:keyint=200:min-keyint=100:hrd=1:vbv_maxrate=12000:vbv_bufsize=12000:no-open-gop=1" -r 50 -crf 22 -force_key_frames "expr:eq(mod(n,100),0)" -codec:a aac -b:a 128k -y target.ts