A title alone cannot show why FFmpeg stops after the first file in a kids’ story playlist. Start by identifying whether your command uses the concat demuxer, filter or protocol, then check the playlist paths and whether the files match the workflow you intended.
If you share the exact command, playlist text, FFmpeg version and full output, someone can help trace the specific failure. Until then, treat each step below as a test, not a diagnosis: a playlist can be syntactically valid and still fail because its inputs or concat method do not fit together.
Capture the command and stopping point
Before changing anything, save the exact command you ran and the complete terminal output. Include the lines before the apparent stop, not just the final error: FFmpeg may report a warning while continuing, or may exit after processing an input without reaching the output you expected. The command tells you how the files were supplied and whether FFmpeg was asked to copy streams, re-encode, or read a playlist.
Record the FFmpeg version as well. You can get it by running ffmpeg -version; keep the first lines with the configuration details if you are asking for help. Also note the operating system, the working directory from which you ran the command, and whether you launched FFmpeg in a terminal, script, scheduler or streaming application. A relative path that works in one directory can fail when a scheduled job starts elsewhere.
Then define what “stops” means in your case. Does FFmpeg exit immediately after opening the first item? Does it create an output that contains only the first story? Does it stop at a timestamp within that file? Does it keep running but wait for input? These outcomes point to different parts of the chain. A playlist read error is not the same as a stream ending early, and neither is the same as a live output disconnect.
For a kids’ story channel, write down a simple expected sequence, such as “intro, story one, story two, end card”, and compare it with the output. If the output is a single file, inspect its duration and seek near the transition. If FFmpeg is sending a live broadcast, distinguish the local input timeline from the YouTube connection. The guide to streaming a Marathi devotional playlist continuously covers the broader scheduling problem; here, first establish whether the local FFmpeg concatenation is actually producing the intended sequence.
Identify the concat method in use
FFmpeg has three distinct concat approaches. Their names are easy to mix up, but they solve different problems. Look in your command for -f concat, a concat filter expression, or a concat: input URL. If none appears, your workflow may be joining files in another application or passing only one input to FFmpeg.
| Method | Typical signal in a command | Intended job | Main constraint |
|---|---|---|---|
| Concat demuxer | -f concat -i list.txt |
Read a text list of files as one virtual input | The files need compatible streams, codecs and time bases; list syntax and paths must work |
| Concat filter | -filter_complex with concat |
Join streams through a filter and usually re-encode | Inputs must be mapped and normalised for the filter’s output workflow |
| Concat protocol | An input such as concat:file1\|file2 |
Join data at file level where the container format supports it | It is not a general playlist mechanism |
The FFmpeg FAQ on concatenating files distinguishes the demuxer, filter and protocol. The first question is not “which command fixes it?” but “which method did I choose, and does that match the files and desired output?”
A common playlist workflow uses the concat demuxer. It reads a script with one file directive for each item, then exposes the sequence as a single input to the rest of the command. If your command instead names only the first MP4, FFmpeg has no instruction to discover the other stories. A directory of video files is not automatically treated as a playlist.
The concat filter is a different route: it connects decoded audio and video streams, allowing them to be processed and encoded into a consistent output. That can suit files with differing properties, but it means you need a filtering and transcoding command rather than just a text list. The concat protocol is narrower still. Do not use it as a shortcut for arbitrary MP4, MOV or other containers: file-level joining is only appropriate for formats that support it.
Validate playlist syntax and file paths
For the demuxer, the list is a text file, not a shell script. A basic list looks like this:
ffconcat version 1.0
file 'story-1.mp4'
file 'story-2.mp4'
file 'story-3.mp4'
There should be one file directive for each input, in playback order. The ffconcat version 1.0 marker is optional in some circumstances, but if you use it for automatic format recognition, it must be exactly at the beginning of the file. A blank line, invisible character or byte-order mark before it can prevent recognition. Save the list as plain text and check the first character rather than relying only on how it looks in an editor.
Paths are interpreted relative to the process’s working directory unless you provide paths that resolve from the list’s location under the relevant workflow. Test each entry from the same account and directory that runs FFmpeg. A path that works when you type a command interactively may not work in a scheduled task, service or batch file. Spaces and special characters need appropriate quoting or escaping in the list; shell quoting rules do not automatically apply to the concat script.
The demuxer’s safe option defaults to 1. In that mode it accepts relative paths made from a limited portable character set and can reject absolute paths or names with other characters. If a trusted playlist genuinely needs those paths, -safe 0 can allow them, but first inspect every entry. Do not disable the check for a list assembled from untrusted input: an unexpected path could make FFmpeg read a file you did not intend. The concat demuxer documentation describes the syntax and safe-path behaviour.
Try a deliberately small list with two files and simple relative names in a test folder. If that works, add the remaining entries in batches until the failure returns. This narrows down a typo or problematic filename without changing the source files. If the first item plays but the second does not, verify that the second entry is spelled exactly as the file appears on disk, including its extension and capitalisation where relevant.
If a story filename contains an apostrophe, a backslash or other punctuation, do not guess at escaping. Check the documented quoting syntax and test that entry alone in a minimal list. Keep the original list unchanged until you have a known-good copy; this makes it easier to compare what changed. For more general command-line context on an always-on channel, the FFmpeg and cloud service comparison for a 24/7 podcast stream can help you separate local file assembly from the later broadcast workflow.
Check input streams and codecs
A valid list does not guarantee that the inputs can be joined by the demuxer. Inspect each file with ffprobe, which is distributed with FFmpeg. For example, run ffprobe -hide_banner -i story-1.mp4 and repeat it for the other stories. Compare the audio and video streams: note whether each file has video, audio, both, or extra streams such as subtitles; check the codecs and stream properties rather than assuming that the .mp4 extension means the files are alike.
The concat demuxer expects corresponding streams across files. If one story has H.264 video and AAC audio while another has a different codec, missing audio, an additional stream or a different stream layout, the virtual sequence may not behave as expected. The official concat demuxer documentation explains that the files should have the same streams, codecs and time base. It may still appear to work in a simple test yet produce a bad transition or timestamp issue with the full playlist.
Check whether the media was exported from the same editing preset. A set of narrated stories may come from different sources: one could be a phone recording, another an edited animation, and another a downloaded clip. They may share the same container while differing in resolution, frame rate, pixel format, sample rate or channel layout. Those differences matter particularly when you move from stream copying to a filter-based approach.
If the second file has no audio but the first does, decide what the intended soundtrack should be. If an input has a variable frame rate or an unusual audio layout, note that too. Do not add options blindly to suppress a warning; first establish whether the option changes the output in a way that matches your target player or stream. A kids’ story playlist may need a consistent narration level, but concatenation itself does not normalise loudness or guarantee clean edits.
When asking for help, share the ffprobe output for the first file and the file where the sequence breaks, with private paths redacted if needed. Keep stream details and error messages intact. If you are troubleshooting a live YouTube workflow rather than only creating a joined file, the always-on Odia songs from a Windows PC guide offers relevant operating context, but it does not replace checking the actual media inputs.
Compare time bases and format compatibility
Even where stream types and codecs appear to match, time bases can differ. A time base describes the units used to represent timestamps for a stream. The concat demuxer adjusts timestamps between files; differences in time base or inaccurate stored durations can therefore affect the transition. Symptoms might be a jump, a gap, overlap, missing tail or timestamps that appear to run incorrectly, rather than a neat error saying “file two is incompatible”.
Compare the stream details reported by ffprobe, especially time base, frame rate and duration. Do not infer exact duration from a rounded display in a media player. A file with an incorrect duration value can shift the next file’s timestamps even when both files decode. FFmpeg’s documentation notes that duration information affects timestamp adjustment in concatenated inputs. If you suspect bad duration metadata, verify it before trying to force a duration in the list.
Container and codec compatibility are related but not identical. MP4 is a container; H.264 is a video codec, and AAC is an audio codec. Two MP4 files can have differing stream structures or timing. Likewise, matching codecs do not necessarily mean the time bases and other stream properties align well enough for a direct virtual concatenation.
Set the target before choosing a repair. Are you making one downloadable file, creating a continuous input for a live encoder, or producing a playlist that cycles indefinitely? A successful one-time join answers only the first two questions if your command handles looping elsewhere. Repeating a file and joining files are separate operations; a command can finish correctly after one pass because nothing told it to loop.
For a clean diagnostic, test the first and second files together as a short output, then test the whole list. Compare output duration and inspect the exact transition. If the output ends precisely at the first file’s duration, revisit list recognition, entry paths and command input. If it continues but has a bad transition, focus on timestamps and media compatibility. This distinction avoids re-encoding an entire library when the actual problem is a missing second list entry.
Choose demuxer or filter for the task
Use the concat demuxer when the files are suitable for being read as a sequence without re-encoding, and their stream structure, codecs and time bases match. It is usually the simpler path for a set of consistently exported stories where you want to avoid another encode. Its simplicity depends on that consistency: the demuxer does not turn unlike files into a uniform programme.
Use the concat filter when you need to decode and re-encode the inputs into a common output, or when their properties need to be made consistent as part of the same processing chain. A filter workflow can set common dimensions, frame rate, audio sample rate or layout, but it requires more explicit input mapping and filter configuration. Re-encoding also takes processing time and may alter quality, so test a short section and review it before doing the full set.
A practical rule is to decide whether you want stream copy or a normalised output. If your files were all exported from one preset and are confirmed compatible, try the demuxer. If they come from mixed sources and the output must have consistent properties, prepare a filter-and-encode workflow. The concat protocol should only be considered if the underlying format supports file-level concatenation; it is not a third spelling for “playlist”.
For a simple demuxer test, a command can begin like ffmpeg -f concat -i stories.txt -c copy joined.mp4. Treat that as a shape to adapt, not a guaranteed command: output container, stream mappings and source properties still matter. If it fails, preserve the error and test a two-file list before adding options. For a filter command, build around the actual number and properties of inputs, and map the filter outputs deliberately rather than assuming the same command fits every story set.
If your real goal is a continuous YouTube channel, separating preparation from transmission can make diagnosis easier. First create or validate a local sequence, then test the broadcast stage. StreamNeo can remove the need to keep a home computer running once a prepared video is ready for a continuous YouTube broadcast, but it does not diagnose or repair a malformed FFmpeg playlist.
Rerun and inspect FFmpeg output
After making one change, rerun with the smallest test that can prove it worked. Use two files first, then expand the list. Keep the command, playlist and output from each run together, with a short note such as “changed second path from absolute to relative”. One change at a time makes it possible to tell whether the result came from fixing a path, adjusting the concat method or changing an input.
Read output from the top. Confirm that FFmpeg recognises the intended input format, reports the expected number of streams, and opens the output you named. Look for messages about unsafe paths, missing files, mismatched streams, invalid data, non-monotonic timestamps or premature end of input. The exact wording can vary by FFmpeg version; do not treat one message in isolation as proof of a single cause.
Use -loglevel warning only if you need a more concise run, and retain a full-output run when investigating. Avoid -v error as your only diagnostic setting because it can hide warnings that explain a damaged transition. For a reproducible report, include the full command with sensitive keys removed, the list file as plain text, the FFmpeg version, ffprobe details for representative inputs and all output from the failing run.
Finally, verify the result rather than relying on a zero exit code alone. Play across every join, listen for narration cut-offs, and confirm the final duration. If the output is meant to feed a live channel, run a short private or otherwise appropriate test and check that the stream receives the full sequence. A local file can be correct while the broadcast command, loop settings or network connection introduces a separate failure.
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 play the first story and then exit?
The title alone is not enough to tell. Check whether the command actually reads a concat list, whether the second file entry resolves from the process’s working directory, and whether FFmpeg reported an error or simply reached the end of a single input. The command and full output are needed to identify the particular cause.
Can I use the concat protocol for a playlist of MP4 stories?
Do not assume so. The concat protocol is for formats that support file-level concatenation, not a general-purpose playlist; for suitable files, inspect the demuxer, and use the filter when a re-encoding workflow is needed. FFmpeg’s concat documentation describes the distinctions.
Do all the story files need the same codec?
The concat demuxer expects corresponding streams and codecs, as well as compatible time bases. If your files differ, a filter-based workflow that decodes and re-encodes to a common output may be more appropriate, but you should test the actual inputs and inspect the result.
What should I share to get a specific diagnosis?
Provide the exact command, playlist text, FFmpeg version, input stream details from ffprobe, and the full output from the failing run. Include where the output stops and what you expected to happen, while removing any private stream keys or credentials.