First check whether FFmpeg is reading a local concat script or an HLS media playlist: they are different formats, and the right diagnosis depends on which one your command uses. A missing file in a concat script is not fixed by an HLS setting, and YouTube’s HLS ingest rules do not apply just because your output goes to YouTube Live.
For a local concat input, work through the script header, paths, order, media streams and timestamps before changing loop options. If you are sending HLS to YouTube, inspect the playlist type and segment naming instead; the checks below keep those two cases separate.
Identify the playlist format first
Read the input part of the command—the options and filename following -i—rather than inferring the format from the destination. A command that contains -f concat -i playlist.txt is asking FFmpeg to read a concat script: a text file with directives such as file '/media/one.mp4'. The concat demuxer presents those inputs in sequence as one virtual input. The file extension alone does not establish what the text contains.
An input ending in .m3u8 may instead be an HLS playlist, with tags such as #EXTM3U and #EXTINF followed by segment references. A command may also generate HLS output rather than consume an HLS playlist. Those are different roles: check whether .m3u8 appears after -i, or in the output options and destination.
| What the command reads | What to inspect first | What not to assume |
|---|---|---|
Local concat script, typically with -f concat |
Header, file directives, paths, streams and durations |
That HLS ingest settings will repair it |
| HLS media playlist sent to YouTube | Media Playlist type and segment references and names | That concat-script rules apply |
| Playlist generated as output | Output format and destination | That the output playlist is the source being skipped |
The FFmpeg concat demuxer documentation explains its script format and input requirements. YouTube’s Live HLS delivery guidance covers the separate HLS ingest path. Keep both pages open only if your workflow genuinely involves both formats; do not combine their fixes into one general playlist recipe.
Write down the exact input filename and format options. If you cannot tell from the command, preserve the whole command for review, redact the stream key, and check FFmpeg’s log where it opens the input. For an exact diagnosis, the command, playlist text, FFmpeg version, relevant log lines and metadata for the files around the omission matter. Without those, treat possible causes as branches to check, not as a confirmed explanation.
Check the concat list’s first line
If the input is a concat script, inspect the first line before editing individual entries. The optional marker for automatic format recognition is exactly ffconcat version 1.0, at the start of the first line. An extra space, a different spelling, or a byte-order mark before the first character can prevent that header from being recognised as intended.
A small script can look like this:
ffconcat version 1.0
file '/media/one.mp4'
file '/media/two.mp4'
For comparison, a file beginning with #EXTM3U is HLS-style text, not a concat script with a slightly different header. Do not add ffconcat version 1.0 to an HLS playlist or replace HLS tags with file lines. First make sure the command selects the matching demuxer and that the text follows that demuxer’s syntax.
The header is optional in some uses when the format is selected explicitly, but a malformed header can still mislead a test that relies on automatic recognition. If the existing command uses -f concat, confirm that the file actually contains concat directives; forcing a format does not turn arbitrary playlist text into valid entries.
When you edit the file, save it as plain text and inspect the first line in an editor that can reveal encoding or unusual leading characters. Then run a short local test and check the log. A successful opening only confirms that FFmpeg has begun reading the script; it does not prove every path exists or every stream can be joined correctly.
Verify file paths and escaping
Each file directive must point to the intended file, using the path as seen by the account running FFmpeg. Check for spelling, directory changes, letter case where the filesystem distinguishes it, and whether the file is still present. A path that works in your desktop file manager may fail when the command runs under another user or from a different working directory.
Paths containing spaces or special characters need quoting or escaping according to concat-script syntax. For example, a quoted absolute path is easier to audit than a relative path whose meaning changes with the command’s working directory. Inspect the exact text rather than relying on what you intended to paste. If the log reports that a file cannot be opened, start with the path and access permissions, not the encoder settings.
FFmpeg’s -safe 0 option can relax the concat demuxer’s default path restrictions when your script uses paths it rejects. It does not correct a typo, create a missing file, grant read permission or make a relative path point to the right directory. Use it only when the paths are understood and the restriction is the issue; do not add it as a ritual fix.
For a local test, use a copy of the list and a short sample command that stops before publishing to YouTube. Keep the playlist and media files in their intended locations, and note which account runs FFmpeg. If a path includes private information, redact it before sharing, but preserve enough of its structure to show whether it is absolute or relative. This is especially useful when comparing the log’s failed path with the corresponding file line.
Confirm the intended entry order
A concat script plays entries in the order of its file directives. It does not infer a playlist from filenames or sort them into the sequence you had in mind. If the output jumps from one item to another, compare the literal sequence in the script with your intended programme: a duplicate, omitted line or line placed out of order can look like a playback fault.
Make a small table while checking a long list. Include the line number, expected filename and what the log or output shows at that point. If the transition occurs after a particular item, inspect that item and the following entry rather than repeatedly changing the whole list. This narrows the search without assuming the first visible jump identifies the underlying cause.
For a radio-style stream where listeners should know what is playing, sequence and metadata are separate jobs. The guide to showing the currently playing track on a 24/7 YouTube radio stream covers on-screen track information; it will not repair an incorrectly ordered concat script. Keep the text list as the source of playback order and use track labels as a way for viewers to identify what they hear.
If the list is built by another process, compare its generated version with the file FFmpeg actually opens. A correct source playlist does not help if an older copy or a different path is supplied to -i. Keep a backup before changing the order, then test a short run and verify transitions from the output rather than relying solely on the edited text.
Check media compatibility and timing
Concat is not a general-purpose converter. For the demuxer to join files as a continuous input, their stream layouts need to be compatible, including corresponding codecs and time bases. Compare the files around the skipped point as well as the first entry: video dimensions, codec, audio sample rate and channel layout can reveal an outlier that the rest of the list does not contain.
Use ffprobe to inspect each file’s streams and duration. For example, run it on the entry immediately before the jump and the one after it, then compare the output with a file that plays as expected. The FFmpeg ffprobe documentation describes the inspection tool. Record the installed FFmpeg version with ffmpeg -version, since option behaviour and documentation can differ between releases.
A stream-copy command cannot bridge arbitrary differences between source files. If the layouts do not match, either prepare compatible inputs or use a deliberate filter and re-encode workflow. The latter takes more processing and needs its own testing; do not switch to -c copy on the assumption that it will normalise codecs, dimensions or audio. The guide to video transcoding for live streaming explains why conversion is a separate step from playlist parsing.
Duration deserves its own check. The concat demuxer uses file durations to position following files. If a reported duration is wrong—for example, because it was inferred poorly or the media is truncated—the next file’s timestamps may be misplaced, producing a gap or an apparent skip. Compare FFmpeg’s duration with the actual playable duration, and listen or watch near the transition. Where you have a reliable duration and probing is wrong, an explicit duration directive can override the inferred value; do not guess it to hide a different error.
Timestamp handling is not always identical to what a simple edit list suggests. Streams within a file may not end at exactly the same time, and timestamp adjustment across the joined input can expose gaps or discontinuities. A viewer may describe a black interval or missing audio as a skipped entry even when the next file has been opened. Check the log and both audio and video around the transition before concluding the file was omitted.
Test looping and transitions
Finding entries, looping an input and pacing it in real time are separate tasks. FFmpeg’s -stream_loop -1 requests indefinite looping of an input, while -re reads file input at its native real-time pace. Neither option repairs a malformed script, unreadable path, incompatible streams or incorrect duration. Confirm which input each option applies to in the command before copying an example from elsewhere.
A simplified command shape for a local concat input might be:
ffmpeg -re -stream_loop -1 -f concat -safe 0 -i playlist.txt \
-c:v libx264 -c:a aac -f flv 'rtmp://a.rtmp.youtube.com/live2/REDACTED'
This is illustrative, not a universal command. Your files may need different filters or encoding settings, and the ingest protocol must match the one selected for your YouTube live stream. A real stream key must never appear in a public log, screenshot or support post. Redact it before sharing, and do not use a test command that accidentally publishes to a live audience.
For a controlled check, first run a short local output and inspect the sequence and transitions. Test the first item, the entry suspected of being skipped, and the entry immediately after it. Then test the end of the list and loop boundary separately. If the issue occurs only after a restart or at the boundary, that points to a different test case from an entry that cannot be opened on the first pass.
If you are building a continuous channel from recorded programmes, the practical sequence is the same whether the material is sermons, lessons or ambience: verify the source order, test the join, then connect the live destination. The article on streaming recorded Sunday sermons continuously from Windows 11 offers a workflow context, but it should not replace checking your own FFmpeg input and logs.
Inspect the live output
Once a local test passes, inspect the live path separately. Confirm that FFmpeg is sending the intended output format and that YouTube receives a stable picture and sound through the transition. If the local file contains every entry but the live player does not, look at output encoding, timestamps, ingest selection and the receiving preview before returning to the concat list.
For HLS sent to YouTube, follow the HLS branch rather than the concat checks. YouTube’s documentation says it supports Media Playlists and ignores Master Playlists; it also calls for media segment filenames to remain unique across encoder reboots and stream restarts. Those points matter to an HLS ingest workflow, not a local playlist.txt that FFmpeg reads and sends over RTMP.
A single observation in the live player can be ambiguous. A file might have opened but displayed black frames, produced silence, or landed at an unexpected timestamp. Compare the local output, FFmpeg log and YouTube preview at the same transition. Note the time and entry names, without exposing the stream key, so a later test can reproduce the point.
If the local test fails too, collect the complete redacted command, the playlist text, ffmpeg -version, the log lines around the first omission and ffprobe output for the entries immediately before and after it. Preserve order and error wording while removing credentials and private paths. That evidence is more useful than a claim that one particular option always fixes skipped entries.
If you would rather avoid keeping a local computer running after you have prepared the video and channel, StreamNeo takes the uploaded file and YouTube stream key so the broadcast can continue from the cloud, with monitoring and automatic restarts; it is YouTube-only. That addresses the ongoing computer and restart burden, not a malformed FFmpeg script or HLS configuration.
Before committing, compare the operating options on the pricing page. When the file and channel are ready, start free — 24-hour trial, no card.
FAQ
Why does FFmpeg skip a file in my concat playlist?
There is no single cause that fits every list. Check the exact file line, path access, entry order, media stream compatibility, duration and the log at the transition. The command, playlist and relevant media metadata are needed to identify a specific cause.
Does -stream_loop -1 fix skipped entries?
No. It repeats an input; it does not make a missing path readable or correct a bad concat header, incompatible streams or timestamps. Confirm that a single pass plays correctly before testing indefinite looping.
Should I use -safe 0 for every concat list?
No. It relaxes path restrictions, but does not fix a wrong path or missing file. Use it only when a known path is rejected by the default safety policy, and keep the paths under review.
Do YouTube HLS rules apply to a local concat script?
No. YouTube’s HLS guidance is for an HLS ingest path. A local concat script uses FFmpeg’s concat syntax and its own path, stream and duration rules; identify the input format before choosing a fix.