If FFmpeg keeps showing the same cartoon, first check whether the command loops one video or is meant to loop a playlist. -stream_loop -1 repeats the input it is attached to; it does not turn a single video into a rotating playlist.
To rotate through several cartoons, inspect the playlist file, confirm FFmpeg is reading that file as its input, and test the sequence locally before connecting to YouTube. Without the command, file list and FFmpeg version, it is not possible to identify the exact fault, but the checks below separate the common causes.
Identify what is repeating
A repeated picture can come from different parts of the workflow. FFmpeg may be looping one input deliberately; a playlist may contain one usable entry; or a wrapper may restart a completed process with the same file. YouTube’s preview can also make diagnosis confusing if you are looking at a delayed or stale preview rather than the current output.
Start by writing down what you expect to happen and what actually happens. Is the intention to show one cartoon continuously, to play several cartoons in order and then start again, or to advance through a schedule without repeating? Does the same cartoon return at a predictable boundary, or does it begin again whenever the process reconnects? Those details help distinguish media sequencing from process restarts.
Look at the command or script that launches FFmpeg, not only the terminal line you remember typing. A shell script, service manager, container setting or scheduled task may launch FFmpeg again after it exits. If each run names the same file, the apparent loop may be outside FFmpeg’s input-loop option. A process restart is a separate behaviour from advancing through entries in a playlist.
Also establish which input is actually being used. A command can have more than one -i, and input options apply to a particular input according to their position. If you are not sure which file or playlist is in use, capture the full launch command with the stream key removed. Treat that key as a password: do not post it in a public forum, screenshot or log.
Check whether FFmpeg loops one input
Read the complete command from left to right and mark every -i. FFmpeg documents -stream_loop as an input option. Its placement before an -i matters because it applies to the following input. With -stream_loop -1 before a cartoon file’s -i, FFmpeg is being asked to read that file indefinitely. If that is the only input, seeing the same cartoon again is the expected result.
For one prerecorded file, this may be exactly the desired behaviour. For several files, repeating the first file does not mean FFmpeg has discovered or inferred a playlist. The playlist itself must be provided as an input, and the loop option must apply to that playlist input instead. Review the FFmpeg command-line documentation for the meanings and placement of input options; check the documentation for the version you actually run if behaviour differs.
Do not diagnose by copying a streaming command from a search result and changing only the filename. An example that illustrates option placement is not a complete YouTube setup: the output format, encoders, resolution, frame rate, keyframe behaviour, ingest address and key all need to suit your channel. A real command also depends on the source media and the FFmpeg build. Keep examples schematic unless you can verify the full arrangement against your own files and YouTube’s current guidance.
A useful test is to take YouTube out of the picture. Run the intended input through a local playback or output test and observe whether the second intended cartoon ever appears. If the local result repeats one file, the cause is in input selection, playlist parsing or looping, not YouTube ingest. If local playback advances correctly but the live preview does not, investigate the output path separately.
Inspect the playlist and its entries
A concat-demuxer playlist is a text file that lists media files in the order FFmpeg should read them. In a simple case, it begins with the required ffconcat version 1.0 header and has one file entry per media item. The relative paths are interpreted in relation to the playlist’s location, so moving the playlist or running FFmpeg from a different working directory can change which files resolve.
Open the exact playlist file named in the command. Check that it contains the expected entries, that names and extensions match the actual files, and that the list is not a different copy from the one you edited. Paths with spaces or unusual characters deserve careful checking. If you use relative paths, test them from the same working directory as the running process. Absolute paths can be clearer, but should still point to files that the process can read.
The concat demuxer may reject paths it considers unsafe. The -safe 0 option relaxes that check; use it only when you control and trust the playlist and its entries. It is not a fix for a wrong path or a missing file, and it should not be treated as a general permission to load arbitrary external paths. See the FFmpeg concat demuxer documentation for its file syntax, path handling and input requirements.
Look for duplicate entries, too. A playlist that contains the same filename several times will play it several times, even if the list looks longer than one line. Check whether a script regenerates the playlist at launch and whether that script is collecting the intended directory. A directory scan can include old exports or omit files with a different extension. Inspect the generated file rather than assuming the script produced the list you intended.
If the playlist has multiple entries but only the first one is played, check the FFmpeg log for file-open errors, unsupported media, or a failure at the first transition. The log can reveal that the later entries were never opened. When sharing log output for help, remove the stream key and any private paths or account details.
Verify sequence and end-of-list behaviour
A playlist has an order. Confirm that the order in its text file matches the intended programme rather than relying on alphabetical order, file creation time or a directory listing. If a cartoon has been split into parts, use explicit names or a deliberate list so that part-10 does not unexpectedly appear before part-2 under a text sort. Then test a short section around a transition and at the end of the list.
The concat demuxer presents compatible files as a sequence of packets, as though they had been joined. For that to work reliably, source files need compatible streams, codecs and time bases. Different resolutions, frame rates, audio layouts or timestamp characteristics can produce errors or visible and audible artifacts at boundaries. FFmpeg’s concat documentation describes the demuxer constraints; its FAQ on concatenating video distinguishes this approach from using a concat filter when files need processing or re-encoding.
Duration and timestamp information matter. If a file’s reported duration is inaccurate, the next item can begin with a gap, overlap or other boundary problem. A sequence that technically advances may still have a frozen picture or audio discontinuity at the hand-off. Do not treat a successful process exit or a moving progress counter as proof that the transition looks and sounds right.
If sources are not compatible, normalise them to a consistent format or use a filter-based workflow that decodes and re-encodes the material as appropriate. That can make transitions more predictable, but it uses processing capacity and may affect quality. Stream-copying is lighter when formats line up, but it does not magically make dissimilar media compatible. Choose based on the actual files, and verify output rather than assuming one method fits every collection.
End-of-list behaviour should be intentional. If you want the sequence to begin again, the loop should apply to the playlist input, not to a lone cartoon input. If you want the broadcast to stop after the final item, do not configure an infinite loop. If the desired behaviour is to continue with a different schedule, define that schedule explicitly; a restart policy that launches the same command is not a scheduler that chooses the next item.
| Intended behaviour | Input to inspect | What the loop should apply to | Main check |
|---|---|---|---|
| Repeat one cartoon | The cartoon file | That single file | Confirm that repetition is intended |
| Cycle through several cartoons | The concat playlist and every entry | The playlist input | Test order and the transition back to the first item |
| Stop after a finite sequence | The playlist and its final entry | No infinite loop | Confirm the process ends as intended |
| Resume after a process failure | The launcher and restart policy | Separate from media looping | Confirm what file or playlist a restart selects |
Test playback before streaming
Make a small local test with representative files, including the ones most likely to cause trouble: a long file, a file with different audio, or one encoded differently from the rest. Watch through at least one transition and, if cycling is intended, the point where the playlist returns to its first entry. Listen as well as watch. A black frame, a burst of silence, clipped audio or a pause can be missed if you inspect only the command output.
For prerecorded input, -re tells FFmpeg to read at native rate, pacing the media as though it were arriving live. It is relevant when sending a file to a live output, but it is not a playlist mechanism and will not fix a wrong input. FFmpeg cautions against using it with an actual live input, where the source already arrives in real time. Refer to the FFmpeg documentation and test with your source type in mind.
Keep the first test short enough to inspect and long enough to cross a file boundary. If the files are large or your machine is encoding in real time, watch whether the process can sustain the chosen output settings without falling behind. A local test cannot prove a home internet connection or a remote process will stay up overnight, but it can expose a sequencing error before you publish it.
If the local test shows the right cartoons in the right order, save the exact command and playlist that produced it. Then change only the output destination and the settings required for YouTube, rather than making several unrelated changes at once. This gives you a way back if the live result differs. Keep a copy of the working playlist and record which FFmpeg version was used.
Check the complete YouTube output workflow
Once the media sequence is correct, confirm the separate live-output pieces. YouTube Live Control Room provides the ingest URL and stream key for the broadcast. Use the current values shown for your stream, and keep the key private. YouTube describes encoder setup in its create a live stream with an encoder guide and explains the URL and key in manage live stream settings.
Use the current YouTube encoder settings guidance to choose a codec, resolution, frame rate, bitrate and keyframe interval. Recommendations depend on the selected output format; do not copy a bitrate from a different resolution or codec just because it appears in an example. Match the output to what your encoder and connection can sustain, then confirm the actual stream health in Live Control Room. YouTube recommends RTMPS for encrypted ingest, so use the secure address offered in Control Room when it is available for your workflow.
A sequence that works locally can still fail as a live broadcast because of network loss, output configuration, a stopped process or a YouTube-side issue. Watch the preview and stream-health indicators during a controlled test. Check that the picture advances across a cartoon boundary, that audio is present, and that the stream remains connected. A loop in the media does not supervise FFmpeg or repair a broken connection.
For a machine you manage yourself, plan separately for process supervision, power, network and disk conditions. A restart policy can bring a process back after a failure, but it may restart at the same item and it does not prove the playlist has advanced. If your stream runs from a small computer, the Raspberry Pi FFmpeg loop-stream guide is relevant to unattended operation, while troubleshooting FFmpeg reconnect errors covers a different failure layer: reconnecting is not the same as choosing the next cartoon.
There are cases where avoiding a locally supervised FFmpeg process is the practical answer. If your specific pain is keeping your own computer on and watching for a dropped process, StreamNeo takes an uploaded video and runs it as a 24/7 YouTube broadcast, with the computer switched off; it does not change the need to prepare the right material or confirm the intended playlist behaviour. It is YouTube-only, so it is not a fit if you need to broadcast to another platform.
Do not assume one continuous FFmpeg process guarantees one complete YouTube archive. YouTube’s encoder setup guidance describes automatic archiving for streams under 12 hours; that statement does not establish how a particular 24/7 broadcast will be archived. Check the current YouTube guidance and your channel’s workflow if retaining the full programme matters. You can also review YouTube Live Control Room and always-on channel options before deciding how you want to manage a broadcast.
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 keep showing just one cartoon?
Most often, the command has a single cartoon file as its input and an infinite loop option applied to that input. If you intended to rotate through several files, inspect whether the command actually reads a playlist and whether that playlist contains the expected entries.
Does -stream_loop -1 cycle through every file in a folder?
No. It repeats the input that follows the option; it does not scan a folder or create a playlist. To cycle through several items, provide an explicit playlist input and apply looping to that input.
Why does a playlist stop or glitch at a transition?
The next file may be missing, unreadable or incompatible with the preceding file’s streams, codecs or time bases. Incorrect duration or timestamp information can also produce boundary artifacts, so test transitions with the actual files and inspect the FFmpeg log.
Is a looping FFmpeg command enough for a 24/7 YouTube stream?
No. It controls media playback, not process supervision, internet reliability or YouTube’s archive behaviour. Test the sequence locally, configure the current YouTube ingest settings, monitor stream health and plan separately for failures and archiving.