To repeat a church service recording, write a text playlist that names the video once for each pass, then use FFmpeg’s concat demuxer to render those passes into one finite video file. That file is not a YouTube Live broadcast: upload it through YouTube Studio, or use a separate live-streaming workflow if you need a channel to broadcast continuously.
For matching source streams, stream copy can join the listed passes without re-encoding. If the streams, codecs or time bases differ, or the joins have timing problems, use a re-encoding workflow instead. The checks below help you decide which path fits your recording before you commit to a long render.
When repeated recordings make sense
A repeated file can be useful when a church wants a service recording to remain available for viewers who arrive at different times, or when a fixed sequence needs to play more than once as an on-demand video. The concat demuxer makes a single output from an ordered list; it does not keep playing indefinitely by itself. A playlist with three entries creates three passes and then ends.
That distinction matters when you plan a channel. If the goal is a recording that viewers can watch later, the rendered file can be uploaded as a video. If the goal is an always-on YouTube Live channel, the file still needs to be sent through a separate broadcast process. FFmpeg’s concat operation prepares media; it does not create a YouTube broadcast or publish anything to your channel.
Before editing, decide how many repetitions are useful and whether they should run back-to-back. A service may begin with a welcome, include announcements and a sermon, then end with a closing prayer. Repeating that entire recording also repeats the opening and closing. If those repeated transitions would be confusing, make a deliberate edit or create separate files for the sections you want to repeat rather than expecting the playlist to change the programme.
Also confirm that you have permission to reuse the recording and its music, readings and other material in the way you intend. Check YouTube’s current guidance for any rights or account questions; a successful render does not establish that a video is cleared for publication.
If you are actually preparing a computer-based live loop rather than a file for upload, keep the distinction clear. A guide to looping a long MP4 in OBS without audio drift addresses playback during a live setup, which is a different job from rendering a finished repeated file.
Prepare the files and working folder
Create a working folder that contains the source recording and the playlist. Keeping the two together makes a relative path easy to use and reduces the chance that a playlist works on one computer but fails after files are moved. Give the source a short, unambiguous name such as service.mp4; avoid renaming or moving it while FFmpeg is running.
Use a copy of the original as your working input if you may need to make further edits. Before rendering, play the source from start to finish, or at least inspect its beginning, end, audio and any points you expect to meet at a join. Note the intended number of passes. A playlist is a script of filenames, not a request to repeat a file forever.
A simple folder might look like this:
church-project/
service.mp4
list.txt
Open a plain-text editor to create list.txt. Use a text editor rather than a word processor, which may save formatting or other characters that FFmpeg does not expect. In particular, if you include the special first-line marker shown below, it must begin at the first character of the file, without a byte-order mark or leading spaces.
Run the command from the working folder, or make sure the paths in the playlist correctly point to the source. Relative filenames such as service.mp4 keep the script portable when the folder is moved as a unit. Files with spaces or special characters need quoting or escaping; the simplest volunteer workflow is to use plain filenames without those characters.
If the source recording is very large, check that you have enough free storage for the output as well as the input, especially if you will re-encode. A stream-copy output may be quicker to produce because the media is not being re-encoded, but output size still depends on the source and the number of listed passes. Do not start a render on the only copy of a file that you cannot replace.
Write the concat-demuxer playlist
The concat demuxer reads a text script and processes its entries in order. Put one file directive in the script for each pass you want. For three repetitions of the same recording, list.txt should contain:
ffconcat version 1.0
file 'service.mp4'
file 'service.mp4'
file 'service.mp4'
The ffconcat version 1.0 line is an exact marker. Keep it on the first line, with no leading blank line, spaces or byte-order mark. When the marker is recognised, FFmpeg can identify the script format automatically; in the command below, the explicit -f concat also tells FFmpeg to use the concat demuxer.
Each repeated file line represents another pass. To change the total, add or remove entries rather than expecting a setting in the render command to change the number of repetitions. The order is meaningful: if you want a different sequence, list the filenames in that order. For example, you could list a sermon recording between two shorter parts, but only if those inputs meet the compatibility requirements for the demuxer or you use a re-encoding approach.
A relative path is read from the location FFmpeg uses to resolve the playlist, so run the command from the folder shown in the example or adjust the paths deliberately. With -safe 1, the example uses safe relative paths. Absolute paths may be rejected by the safety checks and may require -safe 0; only use that option with a playlist you control, because it relaxes path safety checking.
For filenames containing apostrophes or other awkward characters, quoting alone may not be enough: concat-script escaping rules apply. Rather than guess at an escape sequence during a volunteer handover, renaming a working copy to a simple filename is often easier. Keep the original name recorded elsewhere if that matters to your archive.
Render the repeated recording with FFmpeg
For a compatible source, open a terminal in the working folder and run:
ffmpeg -f concat -safe 1 -i list.txt -c copy service-looped.mp4
The input is the playlist, not the video directly. -f concat selects the concat demuxer, -safe 1 permits the safe relative paths in this example, and -i list.txt supplies the script. -c copy asks FFmpeg to copy the encoded streams into the output container rather than decoding and encoding them again. The last filename is the rendered output.
Use a new output name instead of writing over the source. Watch for error messages in the terminal, and do not assume the render completed just because an output file appeared. Wait for FFmpeg to finish and return to the command prompt. Then inspect the output and its duration. If the command reports that the streams cannot be concatenated cleanly, stop and investigate rather than treating the message as a harmless warning.
A fixed playlist produces a finite output. FFmpeg also has a -stream_loop -1 option for repeatedly reading an input during an FFmpeg operation, and an output -t option can stop writing after a target duration. These are different controls from repeating entries in a concat playlist. They are useful in some workflows, but they do not turn a rendered file into a YouTube Live broadcast. For a volunteer who needs a clearly counted set of passes, listing each pass makes the intended sequence visible in the text file.
Keep a copy of the playlist alongside the output. If a church administrator asks how the file was assembled, the script shows the order and number of passes. It also makes a later adjustment straightforward: edit the playlist, choose a new output filename and render again.
The FFmpeg concat-demuxer documentation describes the script format and the input requirements. If you are operating a broadcast separately, a guide to setting up FFmpeg for a 24/7 YouTube stream on a cloud machine concerns that broadcast process, not this file-rendering step.
Choose stream copy or re-encoding
Stream copy is appropriate only when the inputs have matching streams, codecs and time bases. The concat demuxer joins packet streams; it does not fix incompatible media. Repeating the same unchanged recording is a promising case because every playlist entry points to the same source, but the result still needs a playback check. FFmpeg’s guidance does not make stream copy a general solution for files that merely look similar.
If you are combining multiple recordings, compare their actual stream properties rather than relying on filenames or the fact that they were recorded at the same service. Differences in audio or video streams, codecs or time bases can make demuxer concatenation unsuitable. Differences in stream duration or inaccurate duration metadata can also lead to timestamp gaps or artefacts around joins.
| Situation | Practical route | Trade-off |
|---|---|---|
| Repeated entries all refer to the same compatible recording | Try the concat demuxer with stream copy, then inspect every join | Avoids re-encoding, but does not correct faulty timing or source metadata |
| Source files have different streams, codecs or time bases | Normalise them or use the concat filter and re-encode | Adds a render step and requires choosing output settings, but gives a path for incompatible inputs |
| The streams appear compatible but the joins show gaps or artefacts | Investigate durations and timestamps; re-encode if needed | Takes more diagnosis than simply repeating the command |
| You need a live channel rather than a downloadable or on-demand file | Prepare a separate live-broadcast workflow | The concat render alone does not publish or broadcast the recording |
When re-encoding is needed, FFmpeg’s concat filter is the relevant approach. The FFmpeg FAQ recommends that method when the operation needs re-encoding. In practice, the inputs may need to be normalised to compatible properties before they are joined; otherwise, the same underlying differences can remain at the filter stage. Choose consistent video and audio settings for the intended output, and test a short sample before rendering a long programme.
Re-encoding means decoding and encoding the media again. It can take longer and may alter quality, so do not choose it merely because it sounds more complete. Choose it when your files are not suitable for stream copy or when a test shows timing trouble that you cannot resolve by correcting the inputs. If you are not comfortable with FFmpeg filter syntax, make a short test with someone who can check the command before committing the only working copy.
Check the output before uploading to YouTube
The render and the YouTube upload are separate tasks. First inspect service-looped.mp4 locally. Check that it opens, that the picture and sound play, and that the duration is plausible for the number of passes. Most importantly, play across every join: near the end of the first service, through the transition into the next pass, and at each later join. Listen for a sudden cut, silence, repeated fragment or audio change, and look for a freeze or jump in the picture.
If the output duration is unexpectedly short or long, revisit the playlist and source metadata before upload. FFmpeg notes that inaccurate input duration information can produce artefacts, and inputs with streams of differing lengths can result in timestamp gaps. A file that plays correctly at the start may still have a problem at a later join, so spot-checking only the opening is not enough.
Once the file passes those checks, upload it through YouTube Studio. YouTube’s recommended upload encoding settings list MP4 with H.264 video, progressive scan and AAC-LC among suggested settings, as well as a frame rate that matches the recording. The page describes detailed recommendations for partners using YouTube Studio Content Manager, so treat those as guidance rather than universal requirements for every upload. Its guidance also includes a 48 kHz audio sample rate and BT.709 for SDR; check the current official page if you are selecting export settings.
After uploading, allow YouTube to process the file. Processing time can vary with quality, length, format and traffic. Uploading imports the file to YouTube; it is not the same as making it public. Review the processed video in Studio, choose visibility and publication timing, and confirm that the correct version is selected before you publish. YouTube’s uploading videos Help page explains the Studio upload flow; check it for current interface steps.
Keep the source, playlist, final output and a note of the upload status together until you have reviewed the processed video. If you need a separate ongoing live channel, do not leave that requirement implicit in the upload plan. Confirm which tool or workflow is responsible for broadcasting and how it will be monitored. When the pain is that a live broadcast needs to keep running without leaving a volunteer’s computer on, StreamNeo can take an uploaded video and run it as a YouTube live stream; it is YouTube-only and is not a substitute for building or checking this local render.
Common playlist and file issues
FFmpeg does not recognise the playlist. Check that you passed -f concat -i list.txt, that the text file is plain text, and that the marker is exactly at the start of the first line. A blank line or hidden byte-order mark before ffconcat version 1.0 can prevent automatic recognition. The explicit format option is still useful in the example, but the marker itself should be correct.
The source file cannot be found. Check the working directory and the spelling and capitalisation of the filename. Relative paths are resolved from the playlist context used by the command, so running the same command from another folder may not locate the source. Keep the playlist and source together and run the command in that folder, or deliberately update the path.
The path is rejected as unsafe. The example uses -safe 1 for a simple relative filename. If you genuinely need an absolute path and FFmpeg rejects it, -safe 0 may be required, but use it only when you control the playlist and its entries. A relative path and a tidy project folder are easier to review and less error-prone for handover.
The render has a gap or strange transition. Check playback over the join and consider duration metadata, stream lengths and compatibility. Do not try to solve a mismatch by adding more copies of the same line. If the inputs are not suitable for the demuxer, normalise them or use a concat-filter re-encoding workflow.
The output exists but will not play as expected. Wait for FFmpeg to finish and inspect its terminal output for errors. Confirm that the output filename is not accidentally the input filename, and try opening the finished file in a player before uploading. If you re-render after a correction, use a different output name so you can distinguish the checked version from an earlier attempt.
Before you hand the workflow over
A small checklist makes this process easier for the next volunteer. Record which source recording was used, how many entries are in the playlist, which output file passed playback checks, and whether it is intended as an upload or as source material for a separate broadcast. These notes prevent someone from mistaking a finished repeated video for a live stream that is already running.
If your next step is an actual live broadcast, the distinction between preparing a media file and sending it to YouTube matters throughout setup. For a broadcast that uses a local encoder, check the stream health warning guide for a separate discussion of audio and bitrate checks. For a channel scheduled around particular days, planning a YouTube playlist around Indian public holidays covers a scheduling concern rather than the concat command itself.
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 this command create a YouTube Live stream?
No. It renders a finite video file from the entries in your playlist. Uploading that file creates a YouTube video after processing and publication steps; a live channel needs a separate broadcast workflow.
Can I use stream copy for any recordings from the same church?
No. The concat demuxer expects inputs with matching streams, codecs and time bases; recordings from the same church can still differ. When they are incompatible or joins show timing problems, normalise the media or use the concat filter and re-encode.
How many times will the example repeat the service?
Three times, because the playlist contains three file directives. Add or remove directives to set a different finite sequence, then check the rendered duration and joins before uploading.
Should I use absolute paths in the playlist?
Relative paths are usually simpler when the source and playlist are kept together. If you use an absolute path and FFmpeg rejects it, -safe 0 may be needed; only use that with a playlist you control.