我正在尝试使用ffmpeg连接两个mp4文件。我需要这是一个自动过程，因此为什么选择ffmpeg。我将两个文件转换为.ts文件，然后将它们串联，然后尝试对该简明的.ts文件进行编码。这些文件是h264和aac编码的，我希望尽可能保持质量不变或接近原始质量。

ffmpeg -i part1.mp4 -vcodec copy -vbsf h264_mp4toannexb -acodec copy part1.ts
ffmpeg -i part2.mp4 -vcodec copy -vbsf h264_mp4toannexb -acodec copy part2.ts
cat part1.ts part2.ts > parts.ts
ffmpeg -y -i parts.ts -acodec copy -ar 44100 -ab 96k -coder ac -vbsf h264_mp4toannexb parts.mp4

不幸的是，我在编码过程中从ffmpeg返回了以下错误消息：

[h264 @ 0x1012600]sps_id out of range
[h264 @ 0x1012600]non-existing SPS 0 referenced in buffering period
[h264 @ 0x1012600]sps_id out of range
[h264 @ 0x1012600]non-existing SPS 0 referenced in buffering period
[NULL @ 0x101d600]error, non monotone timestamps 13779431 >= 13779431kbits/s    
av_interleaved_write_frame(): Error while opening file

这种情况发生在编码过程的一半左右，这使我认为您无法将两个.ts文件连接在一起并使它正常工作。

FFmpeg具有三种串联方法：

1. concat视频过滤器

如果输入的参数不同（宽度，高度等）或格式/编解码器不同，或者要执行任何过滤，请使用此方法。（您可以仅对不匹配的输入进行重新编码，以便它们共享相同的编解码器和其他参数，然后使用concat多路分配器避免对其他输入进行重新编码）。

ffmpeg -i opening.mkv -i episode.mkv -i ending.mkv \
  -filter_complex "[0:v] [0:a] [1:v] [1:a] [2:v] [2:a] concat=n=3:v=1:a=1 [v] [a]" \
  -map "[v]" -map "[a]" output.mkv

请注意，此方法执行重新编码。

2. concat分离器

如果要避免重新编码并且格式不支持文件级串联（一般用户使用的大多数文件不支持文件级串联），请使用此方法。

$ cat mylist.txt
file '/path/to/file1'
file '/path/to/file2'
file '/path/to/file3'

$ ffmpeg -f concat -safe 0 -i mylist.txt -c copy output.mp4

对于Windows：

(echo file 'first file.mp4' & echo file 'second file.mp4' )>list.txt
ffmpeg -safe 0 -f concat -i list.txt -c copy output.mp4

3. concat协议

将此方法用于支持文件级串联的格式（MPEG-1，MPEG-2 PS，DV）。千万不能用MP4使用。

ffmpeg -i "concat:input1|input2" -codec copy output.mkv

由于这些格式的性质以及此方法执行的简单级联，因此该方法不适用于许多格式，包括MP4。

如果不确定使用哪种方法，请尝试使用concat多路分配器。

另见

• FFmpeg常见问题解答：如何加入视频文件？
• FFmpeg Wiki：如何串联（合并，合并）媒体文件

对于MP4文件

对于.MP4文件（这是我从DailyMotion.com获得：50分钟的电视节目，可下载的仅在三个部分，三个.mp4格式的视频文件）以下是为有效的解决方案的Windows 7，和不NOT涉及重新编码文件。

我重命名了文件（如file1.mp4，file2.mp4和file3.mp4），以使各部分的顺序正确，可以观看完整的电视节目。

然后，我创建了一个简单的批处理文件（concat.bat），其内容如下：

:: Create File List
echo file file1.mp4 >  mylist.txt 
echo file file2.mp4 >> mylist.txt
echo file file3.mp4 >> mylist.txt

:: Concatenate Files
ffmpeg -f concat -i mylist.txt -c copy output.mp4

该批处理文件，并ffmpeg.exe必须都放在同一文件夹中.mp4文件被加入。然后运行批处理文件。通常只需不到十秒钟即可运行。
。

附录（2018/10/21）-

如果您要查找的是无需大量重新输入即可指定当前文件夹中所有mp4文件的方法，请尝试在Windows 批处理文件中尝试此操作（必须包含选项-safe 0）：

:: Create File List
for %%i in (*.mp4) do echo file '%%i'>> mylist.txt

:: Concatenate Files
ffmpeg -f concat -safe 0 -i mylist.txt -c copy output.mp4

在Windows 7上的批处理文件中有效。不要尝试在命令行上使用它，因为它只能在批处理文件中使用！

这是一种无需中间文件即可快速（耗时不到1分钟）且无损的方法：

ls Movie_Part_1.mp4 Movie_Part_2.mp4 | perl -ne 'print "file $_"' | ffmpeg -f concat -i - -c copy Movie_Joined.mp4

“ ls”包含要加入的文件。“ perl”动态创建连接文件到管道中。“-i-”部分告诉ffmpeg从管道中读取

（请注意-我的文件中没有空格或奇怪的东西-如果您要对“硬”文件执行此操作，则需要适当的外壳转义）。

对于MP4文件：

如果它们不是完全相同（100％相同的编解码器，相同的分辨率，相同的类型）的MP4文件，则必须首先将它们转码为中间流：

ffmpeg -i myfile1.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts temp1.ts
ffmpeg -i myfile2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts temp2.ts
// now join
ffmpeg -i "concat:temp1.ts|temp2.ts" -c copy -bsf:a aac_adtstoasc output.mp4

注意！：输出将类似于第一个文件（而不是第二个文件）

我试图将三个.mp3音频文件连接为一个.m4a文件，并且此ffmpeg命令有效。

输入命令：

ffmpeg -i input1.mp3 -i input2.mp3 -i input3.mp3 -filter_complex concat=n=3:v=0:a=1 -f MOV -vn -y input.m4a

的含义： “ -filter_complex concat = n = 3：v = 0：a = 1”：

concat表示使用媒体连接（合并）功能。
n表示确认输入文件的总数。
v意味着有视频？使用0 =无视频，1 =包含视频。有声音
的手段吗？使用0 =无音频，1 =包含音频。-F
表示强制设置文件格式（要查看所有受支持的格式，请使用ffmpeg -formats）
-vn表示禁用视频（-an如果不需要，也将禁用音频）
-y表示覆盖输出文件（如果输出文件已经存在）。

有关更多信息：使用ffmpeg -h full 打印所有选项（包括所有格式和编解码器特定的选项，很长）

我最终使用mpg作为中间格式，并且可以正常工作（请注意，这是一个危险的示例，-qscale 0将重新编码视频...）

ffmpeg -i 1.mp4 -qscale 0 1.mpg
ffmpeg -i 2.mp4 -qscale 0 2.mpg
cat 1.mpg 2.mpg | ffmpeg -f mpeg -i - -qscale 0 -vcodec mpeg4 output.mp4

可以在此处找到有关 ffmpeg中各种串联方式的详细文档。

您可以使用“ Concat过滤器”进行快速串联。

它执行重新编码。当输入具有不同的视频/音频格式时，此选项最佳。

对于串联2个文件：

ffmpeg -i input1.mp4 -i input2.webm \
-filter_complex "[0:v:0] [0:a:0] [1:v:0] [1:a:0] concat=n=2:v=1:a=1 [v] [a]" \
-map "[v]" -map "[a]" output.mp4

对于串联3个文件：

ffmpeg -i input1.mp4 -i input2.webm -i input3.mp4 \
-filter_complex "[0:v:0] [0:a:0] [1:v:0] [1:a:0] [2:v:0] [2:a:0] concat=n=3:v=1:a=1 [v] [a]" \
-map "[v]" -map "[a]" output.mp4

这适用于相同以及多种输入文件类型。

我发现使用选项3在公认的答案中在Mac上连接多个MP4时，管道运算符对我不起作用。

以下一线可在Mac（High Sierra）上连接mp4，而无需创建中间文件。

ffmpeg -f concat -safe 0 -i <(for f in ./*.mp4; do echo "file '$PWD/$f'"; done) -c copy output.mp4

根据rogerdpack和Ed999的回复，我创建了.sh版本

#!/bin/bash

[ -e list.txt ] && rm list.txt
for f in *.mp4
do
   echo "file $f" >> list.txt
done

ffmpeg -f concat -i list.txt -c copy joined-out.mp4 && rm list.txt

它将*.mp4当前文件夹中的所有文件加入joined-out.mp4

在Mac上测试。

结果文件大小是我的60个测试文件的精确总和。不应有任何损失。我所需要的

这对我有用（在Windows上）

ffmpeg -i "concat:input1|input2" -codec copy output

一个例子...

ffmpeg -i "concat:01.mp4|02.mp4" -codec copy output.mp4

蟒蛇

使用一些python代码在一个文件夹中处理尽可能多的mp4（从python.org安装python，将其复制并粘贴并保存到名为mp4.py的文件中，然后使用python从文件夹中打开的cmd中运行mp4.py和文件夹中的所有mp4都将串联在一起）

import glob
import os

stringa = ""
for f in glob.glob("*.mp4"):
    stringa += f + "|"
os.system("ffmpeg -i \"concat:" + stringa + "\" -codec copy output.mp4")

Python版本2

从我博客上的帖子中摘录，这就是我在python中做的事情：

import os
import glob

def concatenate():
    stringa = "ffmpeg -i \"concat:"
    elenco_video = glob.glob("*.mp4")
    elenco_file_temp = []
    for f in elenco_video:
        file = "temp" + str(elenco_video.index(f) + 1) + ".ts"
        os.system("ffmpeg -i " + f + " -c copy -bsf:v h264_mp4toannexb -f mpegts " + file)
        elenco_file_temp.append(file)
    print(elenco_file_temp)
    for f in elenco_file_temp:
        stringa += f
        if elenco_file_temp.index(f) != len(elenco_file_temp)-1:
            stringa += "|"
        else:
            stringa += "\" -c copy  -bsf:a aac_adtstoasc output.mp4"
    print(stringa)
    os.system(stringa)

concatenate()

这里有2个纯bash解决方案，仅使用ffmpeg和不使用

• 中间文件
• perl，python或javascript

一线解决方案使用 ls

ls video1.mp4 video2.mp4 | while read line; do echo file \'$line\'; done | ffmpeg -protocol_whitelist file,pipe -f concat -i - -c copy output.mp4

带0或2+个参数的函数

#######################################
# Merge mp4 files into one output mp4 file
# usage:
#   mergemp4 #merges all mp4 in current directory
#   mergemp4 video1.mp4 video2.mp4
#   mergemp4 video1.mp4 video2.mp4 [ video3.mp4 ...] output.mp4 
#######################################
function mergemp4() {
  if [ $# = 1 ]; then return; fi

  outputfile="output.mp4"

  #if no arguments we take all mp4 in current directory as array
  if [ $# = 0 ]; then inputfiles=($(ls -1v *.mp4)); fi
  if [ $# = 2 ]; then inputfiles=($1 $2); fi  
  if [ $# -ge 3 ]; then
    outputfile=${@: -1} # Get the last argument
    inputfiles=(${@:1:$# - 1}) # Get all arguments besides last one as array
  fi

  # -y: automatically overwrite output file if exists
  # -loglevel quiet: disable ffmpeg logs
  ffmpeg -y \
  -loglevel quiet \
  -f concat \
  -safe 0 \
  -i <(for f in $inputfiles; do echo "file '$PWD/$f'"; done) \
  -c copy $outputfile

  if test -f "$outputfile"; then echo "$outputfile created"; fi
}

注意：在此线程中尝试了一些解决方案，但没有一个让我满意

对于.mp4文件，我发现使用开源命令行工具可以更好，更快地工作mp4box。然后，您可以通过以下方式使用它：

mp4box.exe -add video1.mp4 -cat video2.mp4 destvideo.mp4

对于大多数平台，请在此处下载：https : //gpac.wp.imt.fr/mp4box/

这是我制作的脚本，用于将多个GoPro mp4连接成720p mp4。希望对您有所帮助。

#!/bin/sh
cmd="( "
for i; do
    cmd="${cmd}ffmpeg -i $i -ab 256000 -vb 10000000 -mbd rd -trellis 2 -cmp 2 -subcmp 2 -g 100 -f mpeg -; "
done
cmd="${cmd} ) | ffmpeg -i - -vb 10000000 -ab 256000 -s 1280x720 -y out-`date +%F-%H%M.%S`.mp4"
echo "${cmd}"
eval ${cmd}

从此处的文档中：https : //trac.ffmpeg.org/wiki/Concatenate

如果您有MP4文件，可以先将它们转码为MPEG-2传输流，然后将它们无损连接。对于H.264视频和AAC音频，可以使用以下内容：

ffmpeg -i input1.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts intermediate1.ts
ffmpeg -i input2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts intermediate2.ts
ffmpeg -i "concat:intermediate1.ts|intermediate2.ts" -c copy -bsf:a aac_adtstoasc output.mp4

这种方法适用于所有平台。

我需要将其封装在跨平台脚本中的能力，因此我使用fluent-ffmpeg并提出了以下解决方案：

const unlink = path =>
  new Promise((resolve, reject) =>
    fs.unlink(path, err => (err ? reject(err) : resolve()))
  )

const createIntermediate = file =>
  new Promise((resolve, reject) => {
    const out = `${Math.random()
      .toString(13)
      .slice(2)}.ts`

    ffmpeg(file)
      .outputOptions('-c', 'copy', '-bsf:v', 'h264_mp4toannexb', '-f', 'mpegts')
      .output(out)
      .on('end', () => resolve(out))
      .on('error', reject)
      .run()
  })

const concat = async (files, output) => {
  const names = await Promise.all(files.map(createIntermediate))
  const namesString = names.join('|')

  await new Promise((resolve, reject) =>
    ffmpeg(`concat:${namesString}`)
      .outputOptions('-c', 'copy', '-bsf:a', 'aac_adtstoasc')
      .output(output)
      .on('end', resolve)
      .on('error', reject)
      .run()
  )

  names.map(unlink)
}

concat(['file1.mp4', 'file2.mp4', 'file3.mp4'], 'output.mp4').then(() =>
  console.log('done!')
)

ffmpeg \
  -i input_1.mp4 \
  -i input_2.mp4 \
  -filter_complex '[0:v]pad=iw*2:ih[int];[int][1:v]overlay=W/2:0[vid]' \
  -map [vid] \
  -c:v libx264 \
  -crf 23 \
  -preset veryfast \
  output.mp4

合并当前目录中的所有mp4文件

我个人喜欢不创建以后必须删除的外部文件，因此我的解决方案遵循的是其中包括文件编号列表（例如file_1_name, file_2_name, file_10_name, file_20_name, file_100_name，...）

#!/bin/bash
filesList=""
for file in $(ls -1v *.mp4);do #lists even numbered file
    filesList="${filesList}${file}|"
done
filesList=${filesList%?} # removes trailing pipe
ffmpeg -i "concat:$filesList" -c copy $(date +%Y%m%d_%H%M%S)_merged.mp4

经过下面的各种尝试，脚本在Windows 10 Powershell上为我工作。

    $files=Get-ChildItem -path e:\ -Filter *.mp4


    $files| ForEach-Object  {"file '$($_.FullName)'"}| Out-File -FilePath e:\temp.txt -Encoding ASCII


    if (-not (test-path "e:\ffmpeg\bin\ffmpeg.exe")) {throw "e:\ffmpeg\bin\ffmpeg.exe needed"}

    E:\ffmpeg\bin\ffmpeg.exe -safe 0 -f concat -i "e:\temp.txt" -c copy -bsf:v hevc_mp4toannexb -an e:\joined.mp4

    # Conversion Cleanup
    Remove-Item e:\temp.txt

在这里，前两行创建一个文本文件temp.txt，其内容如下

file 'e:\first.mp4'
file 'e:\second.mp4'

第三，四行检查ffmpeg在路径中是否可用，并创建“ joined.mp4”

与其他答案的主要区别如下

usage  of -bsf:v hevc_mp4toannexb -an

对于上面的mp4文件，您可能需要根据视频编码使用如下所示的其他替代方法。

h264_mp4toannexb

所有此类可能的比特流过滤器都可以在https://ffmpeg.org/ffmpeg-bitstream-filters.html上找到

这是我的方法，该方法使用命令替换和concat视频过滤器（包含完整的MP4文件）加入一个充满MP4文件的目录-认为其他人会从这种单一代码中受益，尤其是如果您有很多文件（我只是一口气加入了17个文件）：

ffmpeg $(for f in *.mp4 ; do echo -n "-i $f "; done) -filter_complex \
"$(i=0 ; for f in *.mp4 ; do echo -n "[$i:v] [$i:a] " ; i=$((i+1)) ; done \
&& echo "concat=n=$i:v=1:a=1 [v] [a]")" -map "[v]" -map "[a]" output.mp4

注意，此命令按照文件的命名顺序（即，如果您运行它们，则显示的顺序）将文件连接在一起ls *.mp4-在我的情况下，它们每个都有一个轨道号，因此效果很好。

这里描述的concat协议； https://trac.ffmpeg.org/wiki/Concatenate#protocol

使用命名管道实现以避免中间文件时

速度非常快（读取：即时），没有丢帧，并且运行良好。

切记删除命名的管道文件，并切记检查视频是否为H264和AAC ffmpeg -i filename.mp4（只需使用即可）（检查h264和aac是否提及）

以可重用的PowerShell脚本的形式接受的答案

Param(
[string]$WildcardFilePath,
[string]$OutFilePath
)
try
{
    $tempFile = [System.IO.Path]::GetTempFileName()
    Get-ChildItem -path $wildcardFilePath | foreach  { "file '$_'" } | Out-File -FilePath $tempFile -Encoding ascii
    ffmpeg.exe -safe 0 -f concat -i $tempFile -c copy $outFilePath
}
finally
{
    Remove-Item $tempFile
}