A skipped video in a YouTube live rotation is not automatically an FFmpeg problem. First establish whether your input is an FFmpeg concat list or an HLS manifest, then check whether the missing clip is absent from FFmpeg’s output or only from YouTube playback.
The cause could be an entry or path error, incompatible streams, inaccurate duration metadata, a timestamp discontinuity, or a downstream ingest or playback issue. The exact command, playlist, media properties and transition logs are needed to identify which applies; changing timestamp flags before that evidence is available can hide the symptom without fixing it.
Identify the playlist format and capture the command
Start by saving the complete command that launches FFmpeg, the playlist or manifest it reads, the FFmpeg version, and the log lines around a skip. Also note which video is affected and whether the jump occurs at the same transition every time. “Playlist” is an everyday word, not a single FFmpeg input type: a text file for the concat demuxer and an HLS .m3u8 manifest use different mechanics.
A concat-demuxer script commonly lists local media files in sequence. It may begin with ffconcat version 1.0, followed by file entries. HLS, by contrast, describes media segments and may include tags for duration and sequence. Do not assume that a file ending in .m3u8 behaves like a concat script, or apply concat-specific fixes to it just because it is called a playlist.
The command tells you how FFmpeg is interpreting the input. Look for the input format option and the file passed with -i; note whether the playlist is passed directly or whether a filter or another demuxer is involved. If you share the command while asking for help, remove stream keys and other credentials first.
Automatic concat-script detection has a detail worth checking: when you rely on it, the optional ffconcat version 1.0 line must be the exact first line. A byte-order mark, blank line or other text before it can stop the expected recognition. Consult the FFmpeg concat demuxer documentation for the format’s rules rather than inferring them from the filename.
Keep a short case record: input type, command, FFmpeg version, playlist contents, affected transition, and whether the skip appears before or after YouTube. That prevents repeated guessing and makes later comparisons meaningful. If you are building a recurring YouTube rotation from recorded lessons, the FFmpeg language-learning stream guide can help with the broader stream setup; here, concentrate on the boundary where the rotation fails.
Check file paths and list order
For a concat list, read the entries as FFmpeg will read them, not as you intended them to be read. Confirm that every file entry exists, that the process can access it, and that relative paths resolve from the relevant working directory. A file copied to another folder, a misspelt extension, or a path with quoting problems can make an item unavailable even though it is visible in a desktop file browser.
Then compare the list order with the intended rotation. Check for a repeated entry, an omitted line, a filename that resembles another, or a line ending that has joined or broken entries. If the missing item is always the same one, ask whether it is present in the script at all. If different items disappear on different runs, investigate access, decoding and timing as well as order.
For paths containing spaces or punctuation, use the quoting form supported by the concat script syntax and test a small copy of the list. Avoid broad search-and-replace edits across many entries until a single-file check confirms the path format. A useful test is to make a temporary list with just the file before the problem, the problem file, and the file after it. That isolates the transition without changing the whole channel rotation.
Do not use a working-directory assumption as a substitute for checking. A playlist may work when launched manually from one folder and fail when a scheduled task or service starts FFmpeg elsewhere. Record the exact launch context and check permissions under the account that actually runs the stream.
If a video is intentionally repeated as part of a longer loop, distinguish a wrong order from a misunderstood loop boundary. The guide to looping an exam-preparation playlist on YouTube Live is relevant to rotation design, but it does not establish that a concat path or order is correct in your specific command.
Inspect stream compatibility and duration metadata
The concat demuxer joins packets rather than decoding every input and rebuilding a common timeline from scratch. FFmpeg documents that corresponding files are expected to have matching streams, including codecs and time bases. Compare the file before the skip with the file after it, and compare both with a file that plays correctly.
Use ffprobe to inspect each candidate file. Capture stream count, stream types, codecs, time bases, frame rates, start times and reported durations. Pay attention to differences such as one file having audio and video while another has video only, differing audio layouts, or a change in video codec. Similar-looking files can still have incompatible stream structure or timing properties.
When the layouts or encoding properties differ, normalising the files to a consistent set of streams and properties before concat is often the practical route. That may mean transcoding a static library once, rather than repeatedly trying to join unlike sources live. It is not the only possible workflow for every case: the right choice depends on whether you need to preserve source quality, whether the playlist changes often, and whether your current pipeline can handle the variations deliberately.
An FFmpeg-user mailing-list response in a case involving varied media properties recommended transcoding a static playlist to common properties before concatenation. Treat that as practical advice for that situation, not as proof that every skipped video is caused by mixed formats. The mailing-list discussion is useful context; the formal requirements are in FFmpeg’s documentation.
Duration needs its own comparison. FFmpeg uses each file’s duration to calculate where the next file’s timestamps begin. The reported duration can be wrong, for example when it is derived from bitrate or when a file is truncated. Compare the reported duration against the actual end of the media, especially for the file immediately before a jump. If duration is inaccurate, the next item can start at an inappropriate timestamp even though it is present and decodable.
Do not override duration simply because a transition looks wrong. Establish the correct media duration first, and inspect the end packets or frames of the preceding file and the start timestamps of the next one. FFmpeg’s concat syntax provides a duration directive, but it is an intervention for a verified duration problem, not a general playlist repair switch.
Review the concat timeline and timestamps
Once paths and stream compatibility are understood, examine what happens at the boundary. The concat demuxer virtually joins the packet streams, offsets timestamps so each file follows the previous one, and expects the next file to begin after the preceding duration. If the input duration is inaccurate, the timestamp offset can be inaccurate too.
For a repeatable skip, compare the last video and audio timestamps from the preceding file with the first timestamps from the following file. Look for an unexpected gap, overlap, reset, or unusually long pause. Also compare whether audio and video move together: a boundary where video continues but audio resets is different from a whole clip being omitted.
A timestamp jump in the input timeline is evidence to investigate the list, packet timing, duration and stream properties. It is not, by itself, a reason to apply a bundle of timestamp flags. Options that alter timestamp handling can affect the whole output and may trade one discontinuity for another. Before changing them, preserve a short reproduction and verify exactly what the output packets show.
If the files have varied frame rates or start times, note that fact alongside the observed boundary. A player can conceal some timing irregularities, while a live encoder or ingest path may expose them. Make one controlled change at a time and replay the same transition. If a duration override is tested, document the measured value used and confirm that both the packet timeline and the visible transition improve.
A continuous playlist should be judged across both audio and video. For a devotional or music channel, even a short audio gap can be more noticeable than a picture cut; the separate audio-gap troubleshooting guide offers a useful way to think about transitions, although an audio gap and a missing video are not necessarily the same fault.
Read transition and FFmpeg logs
FFmpeg’s logs are most useful when you capture the transition rather than only the startup. Keep the complete command output for a test that includes the file before the skip, the suspected item and the following file. Note warnings and errors about opening inputs, decoding, stream configuration, timestamps and output encoding. A line saying that an input could not be opened points in a different direction from a timestamp warning at a boundary.
Increase logging detail only enough to identify the event, and avoid leaving very verbose logging running indefinitely on a production stream. Record the time at which the clip should change, then match that point to the log and, where possible, to a local recording of FFmpeg’s output. The question is not merely whether FFmpeg printed a warning, but whether the output timeline omits the expected content or becomes discontinuous there.
A local capture can be a short diagnostic recording rather than a permanent second stream. Check whether the expected frames and audio are present at the point in question. If they are missing in that recording, trace backwards through the playlist, input decode and concat boundary. If they are present and continuous, preserve that evidence and move downstream rather than repeatedly editing the list.
Logs should be interpreted in context. A warning may be non-fatal, and an output that looks continuous in a local player does not prove YouTube receives the same thing. Conversely, a viewer report of a jump does not demonstrate that FFmpeg skipped a file. Save the exact test conditions so the next run can be compared fairly.
Compare encoder output with YouTube playback
Separate the encoder’s output from what viewers see. Ask two questions: does FFmpeg’s output contain the intended clip, and does the same point appear to jump in YouTube playback? If the local output already omits the clip or has a boundary discontinuity, continue with input, stream compatibility and duration diagnosis. If the local output is continuous but YouTube playback jumps, examine the ingest path and YouTube’s stream-health information.
YouTube recommends monitoring stream health and testing with representative audio and video movement, rather than assuming a static preview proves the full broadcast is healthy. Review the relevant messages in Live Control Room while reproducing the transition. Keep track of whether the issue occurs in the live stream, in a later playback, or only for a particular viewer connection; those observations do not identify a cause on their own, but help locate where to investigate.
For RTMP or RTMPS, YouTube’s current encoder guidance lists supported video and audio codecs, recommends constant bitrate (CBR), and recommends a two-second keyframe interval that should not exceed four seconds. These are checks for the encoded live output and ingest, not remedies for a malformed concat list or a wrong source duration. Follow the YouTube live encoder settings guidance for current requirements and recommendations, since they can change.
A useful comparison is to inspect the source transition, FFmpeg’s output, and the YouTube playback in that order. If the source and local output are sound but stream health reports trouble, investigate encoding and ingest settings. If the local capture is continuous and stream health is clear, try another playback device or connection before making a change to a working input timeline. Do not claim the setup is approved or compliant simply because one test looks normal.
The operating choice also affects how much of this work you must do yourself. Running FFmpeg on a spare computer gives you direct control over the command and logs, but the machine, power and connection must remain available; the guide to preparing a spare PC for 24/7 YouTube streaming covers that side of the decision. If managing a computer overnight is the pain point, StreamNeo removes that particular burden by turning an uploaded video into a YouTube live stream that can keep running with your computer off; it does not diagnose a malformed playlist or make source media compatible for you.
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
Which video gets skipped, and does FFmpeg’s output contain it?
That distinction is the quickest way to separate an input-side problem from a downstream one. If a local capture of FFmpeg output already lacks the clip, inspect the list, paths, streams and boundary timing; if it is present there, investigate YouTube playback and stream health.
Does a skip that repeats at the same transition prove the duration is wrong?
No. A repeatable boundary makes the preceding and following files good candidates for inspection, but list order, stream compatibility, timestamps and downstream ingest can also be involved. Compare reported and actual duration before trying a duration override.
Should I add timestamp flags to stop the skipping?
Not before you know what is wrong. Timestamp options can change the output timeline and may mask a symptom rather than correct a missing entry, incompatible stream or inaccurate duration. Capture the transition and establish whether the discontinuity exists in FFmpeg’s own output first.
What details should I include when asking for help?
Share the full FFmpeg command with secrets removed, the playlist or manifest, FFmpeg version, ffprobe details for the files around the transition, and the relevant log lines. Also say whether the skip is visible in FFmpeg’s output or only in YouTube playback, and whether it happens at the same boundary on repeat.