Fixing video split errors

2025-01-25 15:51 UTC gpt-4o Open in ChatGPT ↗

You can use ffmpeg to split a video into segments of exactly 10 seconds with the following command:

ffmpeg -i input.mp4 -c copy -map 0 -segment_time 10 -f segment output_%03d.mp4

Explanation of the options:

-i input.mp4: Specifies the input video file.
-c copy: Copies the streams without re-encoding (faster and retains quality).
-map 0: Includes all streams (e.g., video, audio, subtitles).
-segment_time 10: Specifies the duration of each segment (10 seconds).
-f segment: Tells ffmpeg to use the segmenting feature.
output_%03d.mp4: Names the output files with a 3-digit numbering format (e.g., output_000.mp4, output_001.mp4).

Notes:

If the video isn’t an exact multiple of 10 seconds, the final segment will contain the remaining duration.
This method is most efficient when no re-encoding is required. If you need to re-encode, replace -c copy with appropriate encoding options like -c:v libx264 -crf 23 -preset fast.

Let me know if you need further help!

Ah, I see the issue. The problem happens because some video formats or codecs require re-encoding when splitting into segments. The -c copy flag can fail if keyframes are not aligned properly within the segment boundaries, leading to invalid segments (e.g., black screens or missing video).

To fix this, you should re-encode the video to ensure each segment starts at a valid keyframe. Here’s the updated command:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset fast -c:a aac -b:a 128k -segment_time 10 -f segment output_%03d.mp4

Explanation of Changes:

-c:v libx264: Re-encodes the video using the H.264 codec to ensure proper splitting.
-crf 23: Specifies the quality of the output video (lower is higher quality, 23 is a good default).
-preset fast: Balances encoding speed and compression efficiency.
-c:a aac -b:a 128k: Re-encodes the audio using AAC at a bitrate of 128kbps.
-segment_time 10: Ensures each segment is 10 seconds long.
-f segment: Splits the video into segments.

For Precise Splits (if Necessary):

If you need frame-accurate splits, add -force_key_frames to enforce keyframes at exact intervals:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset fast -c:a aac -b:a 128k -force_key_frames "expr:gte(t,n_forced*10)" -segment_time 10 -f segment output_%03d.mp4

This ensures that keyframes are placed exactly every 10 seconds, resulting in valid splits.

Let me know if this works!

The issue with black frames at the start of your segments is likely caused by ffmpeg creating segments that don’t align perfectly with the original video’s keyframes. When splitting, ffmpeg might introduce black frames if the segment boundaries don’t match the natural keyframe positions.

To resolve this, you can enforce ffmpeg to generate keyframes exactly at the segment boundaries using the -force_key_frames option. Here’s the corrected command:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset fast -c:a aac -b:a 128k \
-force_key_frames "expr:gte(t,n_forced*10)" -segment_time 10 -f segment output_%03d.mp4

Key Points:

-force_key_frames "expr:gte(t,n_forced*10)": This ensures keyframes are added at every 10-second mark, preventing black frames at the start of segments.
Re-encoding (-c:v libx264): Necessary to create properly aligned keyframes.
Audio Codec (-c:a aac -b:a 128k): Ensures compatibility when re-encoding audio.

If You Want to Avoid Re-Encoding Entirely:

If re-encoding is not acceptable, you can use the -reset_timestamps 1 option and split the video using only -c copy. However, this method may still not guarantee perfect splits due to keyframe misalignment:

ffmpeg -i input.mp4 -c copy -map 0 -reset_timestamps 1 -segment_time 10 -f segment output_%03d.mp4

Test the New Command:

The first method with -force_key_frames should resolve the black frame issue entirely, as it ensures keyframes are properly aligned with the segment boundaries. Let me know how it works!

The issue of progressively increasing segment lengths is due to how ffmpeg handles segmenting with certain formats. By default, ffmpeg tries to avoid cutting streams mid-frame or mid-packet, which can cause segments to grow slightly longer than expected.

To strictly enforce a fixed segment duration of 10 seconds for all files, you can use the -segment_time flag along with the -reset_timestamps 1 option and specify the -force_key_frames flag for keyframe alignment. The following command ensures that every segment is exactly 10 seconds long:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset fast -c:a aac -b:a 128k \
-force_key_frames "expr:gte(t,n_forced*10)" -f segment -segment_time 10 \
-reset_timestamps 1 -segment_format_options movflags=+faststart output_%03d.mp4

Key Points:

-segment_time 10: Ensures each segment is 10 seconds long.
-reset_timestamps 1: Resets timestamps for each segment to start at 0, avoiding progressive duration increases.
-force_key_frames "expr:gte(t,n_forced*10)": Forces keyframes at exact 10-second intervals for precise splitting.
movflags=+faststart: Optimises files for streaming by moving metadata to the start.

If Re-Encoding is Not Acceptable:

If you wish to avoid re-encoding entirely and only copy streams, use this alternative:

ffmpeg -i input.mp4 -c copy -map 0 -f segment -segment_time 10 \
-reset_timestamps 1 output_%03d.mp4

However, without re-encoding, the segments may still deviate slightly in duration due to keyframe alignment.

For Perfectly Accurate Splitting:

If none of the above meets your needs, you can resort to splitting the video with frame accuracy using ffmpeg’s trim filter. However, this requires re-encoding:

ffmpeg -i input.mp4 -vf "select='between(t,0,10)'" -c:v libx264 -crf 23 -preset fast \
-c:a aac -b:a 128k output_000.mp4

Repeat this with t values for each 10-second interval.

Let me know which approach works best for you!