How to Check Audio Duration After a Speed Change: Why 0.8 Takes 25% Longer

A practice track is eight seconds long. You set its speed to 0.8×. Should the result last 9.6 seconds or 10 seconds?

It should last 10 seconds. The speed is 20% lower, but the duration is 25% longer. If you are fitting a rehearsal clip into a fixed slot, confusing those percentages gives you the wrong endpoint before you even export.

I’m Alex from the Creatune team. I tested the duration calculation below with a synthetic WAV in our public speed changer on November 4, 2026. The measurements cover exported file duration and format metadata; they do not establish listening quality or pitch preservation.

Start with the inverse relationship

For a constant speed multiplier s, with no trimming or added padding:

output_duration = input_duration / s
speed_multiplier = input_duration / target_duration

A multiplier describes how quickly you move through the original timeline. At 0.8×, one second of source material needs 1 / 0.8 = 1.25 seconds to play.

For an eight-second source:

The percentage change in duration is (1 / s - 1) * 100, not (1 - s) * 100.

This also works backwards. To stretch eight seconds to ten seconds, request 8 / 10 = 0.8×. If the interface cannot represent your exact multiplier, treat the chosen value as an approximation and measure the export.

Make a source whose duration you know

Use a short WAV you own, or generate the same eight-second fixture with Python’s standard library. No microphone or third-party audio is needed.

import math
import struct
import wave

rate = 44100
frames = rate * 8
samples = [
    round(0.2 * 32767 * math.sin(2 * math.pi * 440 * n / rate))
    for n in range(frames)
]

with wave.open("tone440-8seconds.wav", "wb") as out:
    out.setnchannels(1)
    out.setsampwidth(2)
    out.setframerate(rate)
    out.writeframes(struct.pack("<" + "h" * frames, *samples))

This creates 352,800 frames of mono, 16-bit PCM at 44,100 Hz. The 440 Hz tone supplies a simple signal for the file; counting its frames supplies the exact input duration. A steady tone does not test how a music processor handles drum attacks, voices, or complex mixes.

Export two settings from the same original

Open the English Creatune music speed changer. In the public interface I checked, the Speed control runs from 0.5× to 2× in steps of 0.05, and the output choices are MP3, WAV, and FLAC.

1. Choose tone440-8seconds.wav as the input.
2. Set Speed to 0.8×. Confirm that the input still reads 8.0 s and Total reads 10.0 s.
3. Set the output format to WAV, then select Download. Save or rename this export as speed-080.wav.

1. Keep the original file loaded. Change Speed to 1.25×. The displayed Total becomes 6.4 s.
2. Download another WAV and save it as speed-125.wav.

Use separate filenames so that the second download does not replace the first. Do not load speed-080.wav as the second input: that would test a second processing pass on the ten-second export, rather than a different setting on the original eight seconds.

The page currently states a 50 MB file limit and up to five minutes on desktop, or 2.5 minutes on small screens. This fixture is comfortably inside those limits.

Count frames in the downloaded files

A rounded Total label is useful for setting up the operation. The exported file is the thing to measure before placing it on a timeline.

import wave

for name in (
    "tone440-8seconds.wav",
    "speed-080.wav",
    "speed-125.wav",
):
    with wave.open(name, "rb") as audio:
        frames = audio.getnframes()
        rate = audio.getframerate()
        print(
            name,
            "frames=", frames,
            "rate=", rate,
            "channels=", audio.getnchannels(),
            "bytes_per_sample=", audio.getsampwidth(),
            "seconds=", frames / rate,
        )

Here are the actual file measurements from this test:

Both measured durations match the inverse-speed calculation exactly for this fixture. The exports also have two channels, while the source has one. That is why raw file size is a poor shortcut for checking duration here: channel count changed too.

A frame contains one sample for each channel at one instant. Divide frames by sample rate to get seconds. Do not divide that result by the number of channels.

Diagnose a mismatch without guessing

If a downloaded clip is not the length you expected, check these in order:

• Input identity: was the original file still loaded, or did you accidentally process a previous export?
• Multiplier: did you enter a speed factor such as 0.8, or a percentage such as 20?
• File identity: are you inspecting the newest export with the intended setting?
• Measurement: use decoded frames and sample rate, rather than file bytes or a rounded player label. The Python example above is for PCM WAV; an MP3 needs an appropriate decoder.
• Extra operations: trimming, padding, or a second processing pass changes the calculation. Record those separately before attributing a mismatch to speed.

Matching duration is only one acceptance check. For a rehearsal track, also listen to the beginning, transitions, and ending at a comfortable volume, and judge whether the instruments and words remain useful for your purpose. I did not perform that listening comparison in this test.

Related checks

If your next question is whether the pace itself matches the intended beat, our earlier reproducible click-track tempo check explains how to establish a known BPM reference.

If your workflow joins files with different sample rates, checking duration when joining 44.1 kHz and 48 kHz audio shows why you must read each file’s sample rate before converting frame counts to seconds.