This guide assumes “playlist file” means FFmpeg’s plain-text concat list of local video files. It does not mean an M3U or M3U8 playlist, and the Hindi language of the videos does not call for a special FFmpeg playlist mode.
The concat demuxer reads the file list in order and presents the media as one input. Before sending that input to YouTube Live, check that the listed files are accessible and compatible; a list alone cannot make mismatched streams work reliably.
Confirm the playlist format before you start
An FFmpeg concat list is a text script with a file directive for each local media file. A minimal example is:
ffconcat version 1.0
file 'video-01.mp4'
file 'video-02.mp4'
file 'video-03.mp4'
That is different from a playlist exported by a media player or music application. An M3U/M3U8 file has its own syntax and may refer to web addresses or audio tracks. Do not pass one of those to the concat demuxer as though it were this format; convert or rebuild the list in the format required by the chosen FFmpeg workflow.
The first line shown above is FFmpeg’s optional concat signature. If you use it, it must be exactly the first line, with no leading spaces or byte-order mark. Save the file as plain text, for example playlist.txt. The filename extension is not what makes a file a concat list; its contents and the options supplied to FFmpeg do.
Hindi is the content language, not a playlist format. The same list structure applies whether the videos contain Hindi devotional music, a local news bulletin, or a lecture in another language. Hindi text in filenames may be workable, but consistent, simple filenames reduce quoting and encoding surprises, especially when moving a project between systems.
If you are setting up a continuous recorded programme rather than a one-off playlist, first decide how the sequence should behave when it reaches the last file. A finite list ends. The separate problem of keeping a broadcast live after its input ends is covered in how to keep FFmpeg streaming to YouTube after a video ends.
Prepare the ordered list of local files
Put the playlist and media files in a working directory that FFmpeg can read. Then write one file line per item, in the order you want it played. Relative filenames such as morning-aarti.mp4 are easier to move and review than machine-specific paths. The list is explicit: if a file is missing, misspelled, or placed in a different directory, FFmpeg cannot infer which replacement you meant.
Check the sequence before encoding. Look for duplicates, unwanted gaps, and clips in the wrong order. A spreadsheet or a simple written schedule can help if the playlist is long, but the final text file should contain only the directives and any deliberate duration entries needed by the concat demuxer. Keep a separate copy of the original list before making changes.
The concat demuxer’s default safe mode accepts only safe relative paths and rejects protocol-like or otherwise unsafe path components. That is useful protection against accidentally asking FFmpeg to open an unexpected resource. Prefer a directory you control and relative filenames. Avoid constructing a list from untrusted text or pasting unfamiliar paths into a command without checking what they point to.
If you deliberately need absolute paths or unusual path components, FFmpeg’s -safe 0 relaxes those path checks. Use it only when you trust every entry in the list and have inspected the file. It is not a compatibility switch: it will not repair broken paths, convert codecs, or make unrelated media layouts match.
For example, suppose your files are aarti-01.mp4, pravachan-02.mp4, and bhajan-03.mp4 in the same folder as playlist.txt. A relative list is easy to understand and copy to another machine. If the files instead live across several folders, either organise them together or use carefully reviewed paths and select the safe-mode setting that fits those paths.
Check streams, codecs, and time bases across files
The concat demuxer is most appropriate when each input has the same streams and compatible properties, including codecs and time bases. In practical terms, check whether each clip has the expected video and audio tracks, whether those tracks use the same encoding arrangement, and whether their timing characteristics are compatible. A Hindi video does not become compatible merely because it is in the same language as the other entries.
This distinction matters when a folder has accumulated clips from different sources. One may be a video-only MP4, another may have stereo audio, and a third may use a different video codec or frame rate. A command that copies streams without re-encoding can be efficient when the inputs match, but should not be promised to work on an arbitrary collection of files.
You can inspect files with FFmpeg tools before deciding on a workflow. Compare the stream list, codec names, dimensions, frame rates, sample rates, and time bases rather than relying only on filenames or the fact that all clips open in a player. A media player may conceal differences by decoding each file separately; concatenation has stricter continuity requirements.
| Input situation | Practical choice | Trade-off |
|---|---|---|
| Files have the same stream layout and compatible codecs and timing | Consider the concat demuxer | It can avoid re-encoding, but mismatches may cause errors or playback issues. |
| Files differ in streams or encoding properties | Normalise the files first or use an appropriate concat-filter workflow | Re-encoding takes processing time and requires choices for output format and quality. |
| You need a different ingest packaging method, such as HLS | Follow YouTube’s HLS setup guidance rather than adapting the RTMPS example | HLS has separate segment and playlist rules and is not a drop-in output change. |
FFmpeg documents both approaches: the concat demuxer joins compatible inputs at the demuxing stage, while the concat filter is intended for filter-based concatenation where streams are decoded and can be re-encoded. If the clips differ, normalising them to a deliberate common format may be easier to test than trying to make a stream-copy command accommodate every variation. You can also see how continuity problems surface in a different long-running setup in this guide to fixing OBS audio sync drift.
Create the concat input safely
Open a plain-text editor and create playlist.txt with the signature and file lines. Keep the signature at the top with no hidden character before it. Use one file directive per path and quote paths as needed. Spaces, apostrophes, backslashes, and other special characters require care under FFmpeg’s concat file syntax; simple filenames avoid much of that escaping work.
A safe, uncomplicated folder might contain:
playlist.txt
video-01.mp4
video-02.mp4
video-03.mp4
The corresponding list is:
ffconcat version 1.0
file 'video-01.mp4'
file 'video-02.mp4'
file 'video-03.mp4'
Do not assume that changing a filename to ASCII fixes a media mismatch, or that using -safe 0 makes any source trustworthy. These address different problems: quoting and paths determine whether FFmpeg can locate the intended file; matching streams determine whether the chosen concatenation method can join the media properly.
The demuxer adjusts timestamps so that the first file starts at zero and following files come after it. Incorrect or missing duration information can produce timestamp discontinuities or artefacts at transitions. If a file has known, reliable duration information, an explicit duration directive can help in some cases, but do not guess durations to silence a warning. First check the source file and test the transition where the issue occurs.
Before encoding, open the list and verify that every entry is present, in the intended order, and points to a file you control. Keep the YouTube stream key out of this text file. The playlist describes local media; the key is a credential used separately to connect an encoder to your live event.
Configure FFmpeg output for YouTube Live
YouTube Live provides an ingest server URL and stream key in Live Control Room. FFmpeg uses those values as the destination for the outgoing stream. YouTube explains the connection process in its streaming with an encoder help page; keep the key private and do not paste a real key into a public script, tutorial, or support post.
The following is a structural template, not a universal or tested turnkey command. It assumes compatible files, an installed FFmpeg build with the named encoder, a 30 fps output, and an ingest address and key supplied by your event settings:
ffmpeg -re -f concat -safe 0 -i playlist.txt \\
-c:v libx264 -preset veryfast -pix_fmt yuv420p \\
-r 30 -g 60 -keyint_min 60 -sc_threshold 0 \\
-c:a aac -b:a 128k -ar 44100 \\
-b:v 4500k -maxrate 4500k -bufsize 9000k \\
-f flv 'rtmps://YOUTUBE_INGEST_URL/STREAM_KEY'
Replace the placeholder destination with the exact values from your event, and do not expose the key. The -re option reads the input at its native rate rather than sending the files as fast as the computer can process them. The video and audio options encode an output stream; the example’s rates and dimensions are not suitable for every source or channel.
YouTube’s current live encoder settings guidance calls for RTMP or RTMPS in its general encoder guidance, CBR, supported codecs, and a recommended two-second keyframe interval that must not exceed four seconds. For the example’s 30 fps output, a 60-frame GOP corresponds to two seconds. If you select another frame rate, recalculate the GOP rather than carrying over -g 60 unchanged.
Choose a bitrate using YouTube’s current table for the selected codec, resolution, and frame rate. Its listed H.264 recommendation for 1080p at 30 fps is 10 Mbps, but that is not a universal setting for other resolutions, frame rates, or codecs. The example’s 4500 Kbps video rate should therefore be treated as an illustration, not as YouTube’s recommended rate for every stream. The same YouTube guidance lists AAC or MP3 audio for RTMP/RTMPS; the example’s stereo AAC at 44.1 kHz and 128 Kbps is within its published audio recommendations.
The command uses FLV output, commonly used for RTMP-family streams. Confirm that your FFmpeg build includes libx264 and that the selected codec, pixel format, resolution, frame rate, and bitrates suit your files and YouTube’s current settings. If your channel is built around repeated audio episodes, the podcast playlist guide discusses the wider programming decision; this command still needs to be matched to your own media and live event.
HLS is a separate ingest workflow, documented by YouTube for HDR or codecs not supported by RTMP. It imposes segment and rolling-playlist requirements, including 1–4 second segments and no more than five outstanding segments. It also has higher latency than RTMP according to YouTube. Do not replace the RTMPS destination in this template with an HLS URL and expect the same packaging to work; follow the official HLS ingestion instructions if that is the path your codec or workflow requires.
Test the sequence and inspect playback
A local test catches problems before a live audience sees them. Run FFmpeg against the list while directing output to a local file or otherwise using a non-public test destination, and inspect the beginning, a middle transition, and the end. Listen for missing audio, abrupt changes in loudness, or a gap where one file hands off to the next. Watch for frozen frames, black frames, or a change in aspect ratio.
Then test the intended live setup in YouTube Live Control Room. YouTube recommends a preflight with representative motion and audio, a speed test, and monitoring stream health. Verify that the preview displays the expected picture and sound before making the broadcast public. A successful local decode does not prove the network connection or live event configuration is correct.
Check transitions, not just the opening clip. A sequence can look healthy for several minutes and still fail when a later file has different streams or damaged timing. If the final item has a different loudness or resolution, decide whether to normalise it before streaming. If you are planning a long-running channel, consider the operating conditions as well as the media file: keeping a recorded stream running on an Indian connection covers the practical trade-offs around continuous playback.
A concat list is finite: once FFmpeg reaches the final listed input, it reaches end-of-input. FFmpeg documents -stream_loop -1 as an input option for indefinitely looping an input, but do not assume that placing it around a concat-demuxer input repeats the entire sequence correctly. For a 24/7 channel, the whole list must be repeated by a supported input-generation strategy, and you should test the end-to-start transition, timestamps, and audio continuity. There is no universal one-line whole-playlist loop recipe established by the documentation used here.
If your main concern is that your own computer must remain switched on to run the broadcast overnight, StreamNeo removes that specific burden by turning an uploaded video into a YouTube live stream that continues from the cloud after you switch your computer off. It does not change the need to check media rights, prepare the right files, or review YouTube’s event health.
Troubleshoot file and stream errors
When FFmpeg reports that it cannot open a file, start with the exact path, spelling, directory, and permissions. Confirm that the playlist is in the working directory you expect and that relative paths are resolved from there. If the file contains spaces or quotes, check the concat syntax rather than immediately disabling safe mode. Use -safe 0 only when you have inspected and trust the listed paths.
If the concat demuxer reports stream or codec incompatibility, inspect each file’s streams and compare them. Different video codecs, audio layouts, time bases, or stream counts can make stream-copy concatenation unsuitable. Normalise the files to the same deliberate format, or use a concat-filter workflow that decodes and re-encodes as needed. Do not add arbitrary flags until you know whether the error is about input parsing, media compatibility, or output encoding.
If playback jumps or audio drifts at a boundary, check duration information and timing around that transition. A container may report duration inaccurately, or a clip may have a different frame rate or audio sampling arrangement. Re-test the affected files independently, then test the list again after normalisation. Reliable duration directives may help in specific cases, but fabricated durations can move the error rather than resolve it.
If FFmpeg connects but YouTube does not show a healthy preview, verify the server URL and key from the current event settings, the selected output format and codecs, and the network’s upload capacity. Never share the key in a screenshot or command copied to a public forum. Check YouTube’s current encoder page rather than relying on a saved bitrate from another resolution or an old event; platform recommendations can change.
When a broadcast stops at the last clip, that is expected behaviour for a finite input, not necessarily a network failure. Decide first whether the programme should end or repeat. Test any repeat strategy separately before relying on it overnight, including the final transition and what FFmpeg does if one source file is unavailable.
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
Does Hindi need a special FFmpeg playlist format?
No. Hindi describes the language of the video or audio, not a special concat mode. The same FFmpeg concat-list syntax applies, provided the files are accessible and compatible with the chosen method.
Can I use an M3U or M3U8 file as playlist.txt?
Not as though it were FFmpeg’s concat text format. This guide assumes a plain-text list with file directives for local media; convert or rebuild a different playlist format for the workflow you intend to use.
Will -stream_loop -1 repeat every file in the list forever?
Do not assume that it will repeat the whole concat playlist as you expect. It is an input-loop option, and a 24/7 whole-list workflow needs a supported repeat strategy plus tests for end-of-list behaviour and timestamp continuity.
Can I stream clips with different codecs using stream copy?
Not reliably as a general rule. The concat demuxer expects matching streams and compatible properties; normalise or re-encode the inputs, or use a concat-filter workflow where appropriate.