Zur Navigation springen
Entwickleranleitungen

Leitfaden für Segmente

Übersicht

Mithilfe von Segmenten können Sie in einem API-Anruf verschiedene Audioclips mit unterschiedlichen Zeitbereichen innerhalb eines einzelnen Videos synchronisieren. Dies ermöglicht den lip sync mit mehreren Lautsprechern, indem Sie verschiedenen Teilen Ihres Videos unterschiedliche Audioeingänge zuweisen können. Mithilfe von Segmenten können Sie: - LipSync verschiedener Audioclips mit verschiedenen Teilen Ihres Videos - Verwenden Sie einen bestimmten Teil des Audioeingangs, um ein Segment für ein präzises Timing lippensynchron zu machen - Verwenden Sie sowohl Audio- als auch Text-zu-Sprache-Eingaben, um mehrere Segmente mit unterschiedlichen Eingabetypen in einer einzigen Generation lippensynchron zu machen

Grundkonzepte

Um die Segmentfunktion nutzen zu können, müssen Sie ein segments-Array der obersten Ebene bereitstellen, wobei jedes Element einen Videozeitbereich/ein Videozeitsegment definiert, jedes mit seiner eigenen Audiokonfiguration.

Segment

Jedes Segmentelement verfügt über die folgenden Eigenschaften: <ParamField path=“startTime” type=“double” required={true}> Segmentstartzeit in Sekunden </ParamField> <ParamField path=“endTime” type=“double” required={true}> Endzeit des Segments in Sekunden </ParamField> <ParamField path=“audioInput” type=“SegmentAudioInput” required={true}> Audiokonfiguration mit refId und optionalem Zuschneiden </ParamField> <ParamField path=“optionsOverride” type=“SegmentOptionsOverride”> Überschreiben Sie die Generierungsoptionen für dieses bestimmte Segment </ParamField>

audioInput

Jedes Segment benötigt genau einen audioInput. audioInput übernimmt die folgenden Eigenschaften: <ParamField path=“refId” type=“string” required={true}> Referenz-ID der Audio-/Text-zu-Sprache-Eingabe, die für dieses Segment verwendet werden soll </ParamField> <ParamField path=“startTime” type=“double”> Optionale Startzeit (in Sekunden) zum Zuschneiden des referenzierten Audios. Wenn angegeben, muss auch endTime angegeben werden </ParamField> <ParamField path=“endTime” type=“double”> Optionale Endzeit (in Sekunden) zum Zuschneiden des referenzierten Audios. Wenn angegeben, muss auch startTime angegeben werden </ParamField> Der angegebene audioInput wird zur lip sync des Videosegments zwischen startTime und endTime verwendet.

OptionenOverride

Jedes Segment kann optional die Generierungsoptionen der obersten Ebene überschreiben. Dadurch können Sie unterschiedliche Einstellungen pro Segment anwenden, einschließlich der Ausrichtung auf verschiedene Sprecher. Verwenden Sie für Videos mit mehreren Sprechern active_speaker_detection, um in jedem Segment eine andere Person anzusprechen. Ausführliche Informationen zu den Lautsprecherauswahloptionen finden Sie unter Lautsprecherauswahl - API. <ParamField path=“sync_mode” type=“SyncMode”> Überschreiben Sie den Synchronisierungsmodus für dieses Segment </ParamField> <ParamField path=“temperature” type=“double”> Überschreiben Sie die Ausdruckskraft (0-1) für dieses Segment </ParamField> <ParamField path=“occlusion_detection_enabled” type=“boolean”> Überschreiben Sie die Okklusionserkennung für dieses Segment </ParamField> <ParamField path=“active_speaker_detection” type=“ActiveSpeaker”> Überschreiben Sie Erkennung aktiver Sprecher für dieses Segment. Nützlich, wenn verschiedene Segmente unterschiedliche Lautsprecher haben. Akzeptiert die gleichen Optionen wie der Top-Level-active_speaker_detection: - auto_detect: Automatische Erkennung und Ausrichtung des aktiven Lautsprechers - v3: ASD v3 verwenden - frame_number + coordinates: Geben Sie den Lautsprecher manuell nach Frame und Punkt an - bounding_boxes: Stellen Sie Begrenzungsrahmen pro Frame bereit, wenn Sie über Erkennungsdaten verfügen - bounding_boxes_url: Verweisen Sie auf eine externe JSON-Datei mit Begrenzungsrahmen (empfohlen für lange Videos, um große Anforderungsnutzlasten zu vermeiden). </ParamField>

So funktionieren Segment-Timing und -Dauer

Wenn das Audio- und das Videofenster eines Segments (endTime − startTime) unterschiedliche Längen haben, entscheidet sync_mode, wie die Nichtübereinstimmung behoben wird - und der von Ihnen gewählte Modus ändert die effektive Dauer dieses Segments in der Ausgabe: | sync_mode | Audio länger als das Fenster | Audio kürzer als das Fenster || --- | --- | --- | | bounce | Das Video springt (vorwärts und dann rückwärts), um das Audio zu überdecken | Fenster auf Audio getrimmt | | loop | Video-Loops zur Überdeckung des Audios | Fenster auf Audio getrimmt | | cut_off | Ausgabe auf die kürzere Spur (das Fenster) beschnitten | Fenster auf Audio getrimmt | | silence | spielt den gesamten Ton ab (Video zur Abdeckung aufgefüllt) | vollständige Fensterspiele; Audio mit Stille gepolstert | | remap | Video zeitgestreckt, um es an das Audio anzupassen | Fenster auf Audio getrimmt | Kurz gesagt ist die effektive Länge eines Segments cut_off → min(Audio, Fenster), silence → max(Audio, Fenster) und loop / bounce / remap → die Audiolänge. <Note> Die gleichen Regeln gelten für eine Generation mit einem Segment (nicht segments), bei der das „Fenster“ das gesamte Video ist. Ein 30s-Audio auf einem 15s-Video mit sync_mode: cut_off erzeugt eine 15s-Ausgabe (auf das Video zugeschnitten); silence / loop / bounce / remap erzeugen eine Ausgabe von ca. 30 Sekunden. </Note>

Die Ausgabe kann länger als Ihr Quellvideo sein

Jedes Segment platziert seine Audioaufnahme in einem eigenen Fenster auf der Timeline und jedes Fenster wird erweitert, um es an sein Audio anzupassen (gemäß sync_mode oben). Wenn es Lücken zwischen den Segmenten gibt, verschieben diese erweiterten Fenster den Rest der Zeitleiste - sodass die Ausgabe länger sein kann als das Quellvideo. Beispielsweise können zwei Segmente [1s - 3s] und [5s - 8s] in einem 10-Sekunden-Video eine Ausgabe von ca. 16,8 Sekunden erzeugen: Jedes Fenster wird gestreckt, um die gesamte Audioaufnahme aufzunehmen. Dies ist ein erwartetes Verhalten, kein Fehler. Um die gleiche Länge der Ausgabe wie das Quellvideo beizubehalten, schneiden Sie jede Audioaufnahme mit audioInput.startTime/endTime auf ihr Fenster zu, sodass die Aufnahme genau so lang ist wie das Fenster und das Fenster nicht erweitert wird:

\{
  "startTime": 1,
  "endTime": 3,
  "audioInput": \{ "refId": "audio_1", "startTime": 0, "endTime": 2 }
}

Hier füllt das 2-Sekunden-Audio-Slice genau das 2-Sekunden-Fenster aus, sodass die Zeitleiste - und die Ausgabedauer - an der Quelle ausgerichtet bleiben.

API Anwendungsbeispiele

<AccordionGroup> <Accordion title=“Einzelnes Segment mit einzelnem Audio”> <CodeBlocks>```python from sync import Sync from sync.common import Audio, Video

sync = Sync()

response = sync.generations.create( input=[ Video(url=“https://assets.sync.so/docs/example-video.mp4”), Audio(url=“https://assets.sync.so/docs/example-audio.wav”, ref_id=“audio_1”), ], model=“lipsync-2”, segments=[ GenerationSegment( start_time=2, end_time=5, audio_input=SegmentAudioInput(ref_id=“audio_1”), ), ], )

```typescript
import \{ SyncClient } from "@sync.so/sdk";
const sync = new SyncClient();
const response = await sync.generations.create(\{
    input: [
        \{
            type: "video",
            url: "https://assets.sync.so/docs/example-video.mp4"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/example-audio.wav",
            refId: "audio_1"
        },
    ],
    segments: [
        \{
            startTime: 2,
            endTime: 5,
            audioInput: \{ refId: "audio_1" }
        },
    ],
    model: "lipsync-2"
});

</CodeBlocks> </Accordion> <Accordion title=“Mehrere Segmente mit einem einzigen Audio”>

Mehrere Segmente mit einem einzigen Audioeingang

<CodeBlocks>```python from sync import Sync from sync.common import Audio, Video, TTS

sync = Sync()

response = sync.generations.create( input=[ Video(url=“https://assets.sync.so/docs/example-video.mp4”), Audio(url=“https://assets.sync.so/docs/example-audio.wav”, ref_id=“audio_1”) ], segments=[ { “startTime”: 2, “endTime”: 5, “audioInput”: {“refId”: “audio_1”, “startTime”: 2, “endTime”: 5} }, { “startTime”: 6, “endTime”: 8, “audioInput”: {“refId”: “audio_1”, “startTime”: 6, “endTime”: 8} } ], model=“lipsync-2” )

```typescript
import \{ SyncClient } from "@sync.so/sdk";
const sync = new SyncClient();
const response = await sync.generations.create(\{
    input: [
        \{
            type: "video",
            url: "https://assets.sync.so/docs/example-video.mp4"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/example-audio.wav",
            refId: "audio_1"
        },
    ],
    segments: [
        \{
            startTime: 2,
            endTime: 5,
            audioInput: \{ refId: "audio_1", startTime: 2, endTime: 5 }
        },
        \{
            startTime: 6,
            endTime: 8,
            audioInput: \{ refId: "audio_1", startTime: 6, endTime: 8 }
        }
    ],
    model: "lipsync-2"
});

</CodeBlocks> </Accordion> <Accordion title=“Mehrere Segmente mit mehreren Audiodaten”>

Mehrere Segmente mit einem einzigen Audioeingang

<CodeBlocks>```python from sync import Sync from sync.common import Audio, Video, TTS

sync = Sync()

response = sync.generations.create( input=[ Video(url=“https://assets.sync.so/docs/example-video.mp4”), Audio(url=“https://assets.sync.so/docs/example-audio.wav”, ref_id=“audio_1”), Audio(url=“https://assets.sync.so/docs/example-audio.wav”, ref_id=“audio_2”) ], segments=[ { “startTime”: 2, “endTime”: 5, “audioInput”: {“refId”: “audio_1”, “startTime”: 2, “endTime”: 5} }, { “startTime”: 6, “endTime”: 8, “audioInput”: {“refId”: “audio_2”, “startTime”: 6, “endTime”: 8} } ], model=“lipsync-2” )

```typescript
import \{ SyncClient } from "@sync.so/sdk";
const sync = new SyncClient();
const response = await sync.generations.create(\{
    input: [
        \{
            type: "video",
            url: "https://assets.sync.so/docs/example-video.mp4"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/example-audio.wav",
            refId: "audio_1"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/example-audio.wav",
            refId: "audio_2"
        },
    ],
    segments: [
        \{
            startTime: 2,
            endTime: 5,
            audioInput: \{ refId: "audio_1", startTime: 2, endTime: 5 }
        },
        \{
            startTime: 6,
            endTime: 8,
            audioInput: \{ refId: "audio_2", startTime: 6, endTime: 8 }
        }
    ],
    model: "lipsync-2"
});

</CodeBlocks> </Accordion>

<Accordion title=“Segmente mit Optionsüberschreibung”>

Segmente mit Optionen pro Segment

Verwenden Sie optionsOverride, um auf jedes Segment unterschiedliche Generierungseinstellungen anzuwenden. <CodeBlocks>```python from sync import Sync from sync.common import Audio, Video

sync = Sync()

response = sync.generations.create( input=[ Video(url=“https://assets.sync.so/docs/example-video.mp4”), Audio(url=“https://assets.sync.so/docs/audio1.wav”, ref_id=“audio_1”), Audio(url=“https://assets.sync.so/docs/audio2.wav”, ref_id=“audio_2”) ], segments=[ { “startTime”: 0, “endTime”: 5, “audioInput”: {“refId”: “audio_1”}, “optionsOverride”: { “sync_mode”: “loop”, “temperature”: 0.3 } }, { “startTime”: 5, “endTime”: 10, “audioInput”: {“refId”: “audio_2”}, “optionsOverride”: { “sync_mode”: “cut_off”, “temperature”: 0.7 } } ], model=“lipsync-2”, options={“sync_mode”: “bounce”} # Default for segments without override )

```typescript
import \{ SyncClient } from "@sync.so/sdk";
const sync = new SyncClient();
const response = await sync.generations.create(\{
    input: [
        \{
            type: "video",
            url: "https://assets.sync.so/docs/example-video.mp4"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/audio1.wav",
            refId: "audio_1"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/audio2.wav",
            refId: "audio_2"
        }
    ],
    segments: [
        \{
            startTime: 0,
            endTime: 5,
            audioInput: \{ refId: "audio_1" },
            optionsOverride: \{
                sync_mode: "loop",
                temperature: 0.3
            }
        },
        \{
            startTime: 5,
            endTime: 10,
            audioInput: \{ refId: "audio_2" },
            optionsOverride: \{
                sync_mode: "cut_off",
                temperature: 0.7
            }
        }
    ],
    model: "lipsync-2",
    options: \{ sync_mode: "bounce" }  // Default for segments without override
});

</CodeBlocks> </Accordion> <Accordion title=“Multi-Lautsprecher-Segmente mit Erkennung aktiver Lautsprecher”>

Sprechen Sie unterschiedliche Sprecher pro Segment an

Verwenden Sie active_speaker_detection in optionsOverride, um unterschiedliche Lautsprecher in jedem Segment anzusprechen. Dies ist hilfreich, wenn in einem Video mehrere Personen vorkommen und verschiedene Segmente mit unterschiedlichen Sprechern synchronisiert werden sollen. <CodeBlocks>```python from sync import Sync from sync.common import Audio, Video

sync = Sync()

response = sync.generations.create( input=[ Video(url=“https://assets.sync.so/docs/two-speakers.mp4”), Audio(url=“https://assets.sync.so/docs/speaker-a.wav”, ref_id=“audio_a”), Audio(url=“https://assets.sync.so/docs/speaker-b.wav”, ref_id=“audio_b”) ], segments=[ { “startTime”: 0, “endTime”: 5, “audioInput”: {“refId”: “audio_a”}, “optionsOverride”: { “active_speaker_detection”: { “frame_number”: 0, “coordinates”: [200, 300] # Point on speaker A’s face } } }, { “startTime”: 5, “endTime”: 10, “audioInput”: {“refId”: “audio_b”}, “optionsOverride”: { “active_speaker_detection”: { “frame_number”: 150, “coordinates”: [600, 300] # Point on speaker B’s face } } } ], model=“lipsync-2” )

```typescript
import \{ SyncClient } from "@sync.so/sdk";
const sync = new SyncClient();
const response = await sync.generations.create(\{
    input: [
        \{
            type: "video",
            url: "https://assets.sync.so/docs/two-speakers.mp4"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/speaker-a.wav",
            refId: "audio_a"
        },
        \{
            type: "audio",
            url: "https://assets.sync.so/docs/speaker-b.wav",
            refId: "audio_b"
        }
    ],
    segments: [
        \{
            startTime: 0,
            endTime: 5,
            audioInput: \{ refId: "audio_a" },
            optionsOverride: \{
                activeSpeakerDetection: \{
                    frameNumber: 0,
                    coordinates: [200, 300]  // Point on speaker A's face
                }
            }
        },
        \{
            startTime: 5,
            endTime: 10,
            audioInput: \{ refId: "audio_b" },
            optionsOverride: \{
                activeSpeakerDetection: \{
                    frameNumber: 150,
                    coordinates: [600, 300]  // Point on speaker B's face
                }
            }
        }
    ],
    model: "lipsync-2"
});

</CodeBlocks> Einzelheiten zu den active_speaker_detection-Optionen finden Sie unter Lautsprecherauswahl - API. </Accordion> </AccordionGroup>

Best Practices

Planen Sie Ihre Segmente

  1. Planen Sie Ihre Zeitachse: Identifizieren Sie Videosegmente und entsprechende Audioanforderungen
  2. Audiodateien vorbereiten: Stellen Sie die Audioqualität und die angemessene Dauer sicher
  3. Segmentgrenzen testen: Überprüfen Sie reibungslose Übergänge zwischen Segmenten

Audiovorbereitung - Verwenden Sie eine einheitliche Audioqualität für alle Segmente und den Ton des Videos. - Um optimale Ergebnisse zu erzielen, stellen Sie sicher, dass das Timing richtig auf die Videosegmente abgestimmt ist. Wenn die Segmentdauer und die entsprechende Audiodauer nicht übereinstimmen, verlassen Sie sich auf sync_mode, um zu bestimmen, wie mit der Nichtübereinstimmung umgegangen werden soll.

Fehlerbehebung

Häufige Fehler

<AccordionGroup> <Accordion title=‘„Mehrere Audioeingänge sind nur bei Verwendung von Multisegmenten zulässig“’> Stellen Sie ein segments-Array der obersten Ebene bereit, wenn Sie mehrere Audio- oder Texteingänge verwenden.

# ❌ This will fail
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio1.wav"),  # Multiple audio without segments
        Audio(url="audio2.wav")
    ],
    model="lipsync-2"
)
# ✅ This will work
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio1.wav", ref_id="a1"),
        Audio(url="audio2.wav", ref_id="a2")
    ],
    segments=[
        \{"start_time": 0, "end_time": 10, "audio_input": \{"refId": "a1"}},
        \{"start_time": 10, "end_time": 20, "audio_input": \{"refId": "a2"}}
    ],
    model="lipsync-2"
)

</Accordion> <Accordion title=‘„Audioeingang URL kann nicht aufgelöst werden“’> Stellen Sie sicher, dass alle Audioeingänge über gültige url- oder assetId-Werte verfügen und dass in Ihren Audio- oder Texteingängen referenzierte refId-Werte vorhanden sind.

# ❌ Missing refId reference
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")
    ],
    segments=[
        \{"start_time": 0, "end_time": 10, "audio_input": \{"refId": "missing"}}  # Wrong refId
    ],
    model="lipsync-2"
)
# ✅ Correct refId reference
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")
    ],
    segments=[
        \{"start_time": 0, "end_time": 10, "audio_input": \{"refId": "audio1"}}  # Correct refId
    ],
    model="lipsync-2"
)

</Accordion> <Accordion title=‘„Segment am Index X fehlt eine gültige audioInput.refId“’> Dieser Fehler tritt auf, wenn im audio_input eines Segments ein refId fehlt oder der refId leer ist. Jedes Segment muss über seinen refId auf eine gültige Audio- oder Texteingabe verweisen.

# ❌ Missing refId in segment
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")
    ],
    segments=[
        \{
            "start_time": 0, 
            "end_time": 10, 
            "audio_input": \{}  # Missing refId
        }
    ],
    model="lipsync-2"
)
# ✅ Include refId in segment
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")
    ],
    segments=[
        \{
            "start_time": 0, 
            "end_time": 10, 
            "audio_input": \{"refId": "audio1"}  # Valid refId
        }
    ],
    model="lipsync-2"
)

</Accordion> <Accordion title=‘„Segment am Index X verweist auf unbekannte RefId“’> Dieser Fehler tritt auf, wenn ein Segment auf einen refId verweist, der in Ihren Audio- oder Texteingaben nicht vorhanden ist. Stellen Sie sicher, dass alle referenzierten refId-Werte genau mit den in Ihren Eingaben definierten Werten übereinstimmen.

# ❌ Segment references unknown refId
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")  # refId is "audio1"
    ],
    segments=[
        \{
            "start_time": 0, 
            "end_time": 10, 
            "audio_input": \{"refId": "nonexistent"}  # References unknown refId
        }
    ],
    model="lipsync-2"
)
# ✅ Segment references existing refId
response = sync.generations.create(
    input=[
        Video(url="video.mp4"),
        Audio(url="audio.wav", ref_id="audio1")  # refId is "audio1"
    ],
    segments=[
        \{
            "start_time": 0, 
            "end_time": 10, 
            "audio_input": \{"refId": "audio1"}  # References existing refId
        }
    ],
    model="lipsync-2"
)

</Accordion> <Accordion title=‘„Ungültiger Segmentzeitbereich: startTime muss <= endTime sein“’> Der startTime jedes Segments muss kleiner oder gleich dem endTime sein. Segmente mit der Länge Null (wobei startTime gleich endTime ist) sind für Anwendungsfälle wie Zuschneidepunkte mit Nulldauer zulässig.

# ❌ Invalid: startTime greater than endTime
segments=[
    \{
        "startTime": 10,
        "endTime": 5,  # endTime must be >= startTime
        "audioInput": \{"refId": "audio1"}
    }
]
# ✅ Valid: startTime less than endTime
segments=[
    \{
        "startTime": 0,
        "endTime": 10,
        "audioInput": \{"refId": "audio1"}
    }
]
# ✅ Valid: startTime equals endTime (zero-length segment)
segments=[
    \{
        "startTime": 5,
        "endTime": 5,
        "audioInput": \{"refId": "audio1"}
    }
]

</Accordion> <Accordion title=‘„Ungültiger Segment-Frame-Bereich: startFrame muss < endFrame sein“’> Wenn Segmentgrenzen mithilfe von Frames anstelle von Sekunden angegeben werden, muss startFrame unbedingt kleiner als endFrame sein. Im Gegensatz zu zeitbasierten Segmenten, die gleiche Start- und Endzeiten ermöglichen, erfordern Frame-basierte Segmente mindestens einen Frame mit Differenz.

# ❌ Invalid: startFrame greater than or equal to endFrame
segments=[
    \{
        "startFrame": 100,
        "endFrame": 0,  # endFrame must be > startFrame
        "audioInput": \{"refId": "audio1"}
    }
]
# ❌ Invalid: startFrame equals endFrame (not allowed for frames)
segments=[
    \{
        "startFrame": 50,
        "endFrame": 50,  # endFrame must be > startFrame
        "audioInput": \{"refId": "audio1"}
    }
]
# ✅ Valid: startFrame less than endFrame
segments=[
    \{
        "startFrame": 0,
        "endFrame": 100,
        "audioInput": \{"refId": "audio1"}
    }
]

</Accordion> <Accordion title=‘„Ungültiger AudioInput-Zuschneidebereich“’> Beim Zuschneiden von Audio innerhalb eines Segments müssen sowohl startTime als auch endTime bereitgestellt werden, und startTime muss kleiner oder gleich endTime sein.

# ❌ Incomplete crop range
segments=[
    \{
        "startTime": 0,
        "endTime": 10,
        "audioInput": \{
            "refId": "audio1",
            "startTime": 5  # Missing endTime
        }
    }
]
# ❌ Invalid: startTime greater than endTime
segments=[
    \{
        "startTime": 0,
        "endTime": 10,
        "audioInput": \{
            "refId": "audio1",
            "startTime": 15,
            "endTime": 5  # endTime must be >= startTime
        }
    }
]
# ✅ Valid: complete crop range with startTime \<= endTime
segments=[
    \{
        "startTime": 0,
        "endTime": 10,
        "audioInput": \{
            "refId": "audio1",
            "startTime": 5,
            "endTime": 15
        }
    }
]
# ✅ Valid: zero-duration crop point (startTime equals endTime)
segments=[
    \{
        "startTime": 0,
        "endTime": 10,
        "audioInput": \{
            "refId": "audio1",
            "startTime": 5,
            "endTime": 5
        }
    }
]

</Accordion> <Accordion title=‘„Bei Verwendung von Multi-Segmenten bitte mindestens eine Audio- oder Texteingabe bereitstellen“’> Stellen Sie sicher, dass Sie über mindestens einen Audio- oder Texteingang mit einem gültigen refId verfügen, wenn Sie Segmente verwenden.

# ❌ This will fail - no audio or text inputs
response = sync.generations.create(
    input=[
        Video(url="https://example.com/video.mp4")
    ],
    segments=[
        \{"start_time": 0, "end_time": 10, "audio_input": \{"refId": "missing"}}
    ],
    model="lipsync-2"
)
# ✅ This will work - includes text input
response = sync.generations.create(
    input=[
        Video(url="https://example.com/video.mp4"),
        TTS(
            provider=\{
                "name": "elevenlabs",
                "voiceId": "EXAVITQu4vr4xnSDxMaL",
                "script": "Hello world"
            },
            ref_id="text1"
        )
    ],
    segments=[
        \{"start_time": 0, "end_time": 10, "audio_input": \{"refId": "text1"}}
    ],
    model="lipsync-2"
)

</Accordion> </AccordionGroup> <llms-ignore>

Verwandte Ressourcen - Lipsync-Modell - Erfahren Sie mehr über unterstützte Modelle für Einzel- und Mehrsegmentgenerationen - API-Anleitung für Videosynchronisation - Verwenden Sie Segmente mit Synchronisations-Workflows für die Synchronisation von Videos mit mehreren Sprechern

</llms-ignore>