Prepare source media for a dubbing workflow

Prepare a dubbing source by delivering the intended media, preserving its identity and timeline, and confirming that the dubbing service can actually ingest it. Keep the media acquisition job separate from the dubbing project: a successful download is not a translated or reviewed video.

Tornado provides the media ingestion step in this workflow. Translation, voice generation and editorial approval belong to your downstream dubbing tool and your application. This guide focuses on the handoff, especially when you work with excerpts instead of a complete source.

Decide what the dubbing tool will receive

Start with one authorized source and the requirements of your selected dubbing API. Determine whether it needs a video file, an audio file, a direct media URL or an upload. Check its current format, size and duration constraints before creating a large batch.

For example, ElevenLabs' current create-project reference accepts an uploaded file or a source URL. Project creation returns before source ingestion finishes. That distinction matters: receiving a project identifier does not establish that the source was fetched successfully. Other providers can have different acceptance and processing stages.

If the output will be a dubbed video, retain the video associated with the audio you submit. An audio-only input can be useful for an audio workflow, but it does not preserve the picture your editor may need later. Keep a reference to the original delivery rather than trying to identify it again from a title.

Preserve the intended excerpt and its timeline

Tornado's create-job reference documents audio-only output and clipping fields including clip_start and clip_end. These describe the requested ingestion operation. Inspect the delivered media before treating its timing as an editorial reference.

When a dubbing project starts at the beginning of an excerpt, its time zero may correspond to a later position in the original source. Record that relationship explicitly. A subtitle segment at five seconds in the excerpt should not automatically be placed at five seconds in the original full-length video.

Use separate records for requested boundaries, observed duration and any verified timeline offset. Do not rename a requested start time to “verified offset” without checking it. Cutting behavior, timestamp normalization and later edits can affect the relationship.

A compact handoff record can keep these responsibilities visible:

These are application fields, not a proposed Tornado response schema.

Map excerpt timestamps only under explicit assumptions

The following example maps a segment from an excerpt timeline to its original source timeline. It assumes an unchanged playback rate, no internal cuts, and a verified offset. Integer milliseconds avoid introducing decimal rounding into this simple addition.

def source_interval(start_ms, end_ms, clip_duration_ms, offset_ms):
    values = (start_ms, end_ms, clip_duration_ms, offset_ms)
    if any(type(value) is not int for value in values):
        raise ValueError("Use integer milliseconds")
    if offset_ms < 0 or not 0 <= start_ms < end_ms <= clip_duration_ms:
        raise ValueError("Invalid segment or offset")
    return (offset_ms + start_ms, offset_ms + end_ms)


# Synthetic 30-second excerpt whose verified origin is 90 seconds.
assert source_interval(5000, 8000, 30000, 90000) == (95000, 98000)
assert source_interval(0, 30000, 30000, 90000) == (90000, 120000)

for invalid in [
    (-1, 8000, 30000, 90000),
    (8000, 5000, 30000, 90000),
    (0, 31000, 30000, 90000),
    (0, 1000, 30000, -1),
    (0, 1000.5, 30000, 90000),
]:
    try:
        source_interval(*invalid)
    except ValueError:
        pass
    else:
        raise AssertionError("Invalid interval was accepted")

The two valid mappings and five rejection cases were executed locally. No media was downloaded or dubbed to test this example. It checks arithmetic and boundaries, not synchronization, cut accuracy or speech alignment.

If an editor removes pauses, rearranges scenes or changes playback speed, a single offset no longer describes the relationship. Store an edit mapping appropriate to that transformation, or work against the exact edited source throughout the dubbing project. Do not apply this helper to a stitched sequence as though it were one continuous excerpt.

Verify access before handing off a URL

A source page URL and a delivered media URL serve different purposes. Use the input form required by the dubbing service. If you pass a temporary delivery link, the service must be able to fetch it when ingestion actually runs, not merely when your application submits the request.

Keep signed links private and preserve their query strings. For asynchronous work, choose a supported file upload or an access path whose lifetime covers ingestion and the recovery policy you need. Retain the stable object reference separately from temporary access credentials.

When a fetch fails, inspect the dubbing project's reported cause and the existing media's accessibility before creating another Tornado job. The expired-link guide separates access failure from missing media. For your own bucket, the S3 delivery guide covers the object handoff.

Review the source and the final dub separately

Before dubbing, listen to representative sections of the delivered input: the beginning, a speaker change and the ending. Confirm that the intended speech is present and that the excerpt does not accidentally omit context. Check the actual audio format using the audio output guide, adapting its consumer requirements to your dubbing tool.

After dubbing, review pronunciation, translation, speaker attribution and timing in the downstream result. Successful ingestion cannot establish those qualities. Save the reviewed output's identity and target language so a later retry does not silently replace an approved version.

Start with a short representative workflow, record both job identifiers, and exercise a failed downstream fetch before scaling. Follow the first media workflow for submission and delivery; add dubbing only after the source handoff is repeatable and inspectable.