Ich versuche zwei mp4-Dateien mit ffmpeg zu verketten. Ich brauche dies, um ein automatischer Prozess zu sein, deshalb habe ich mich für ffmpeg entschieden. Ich konvertiere die beiden Dateien in .ts-Dateien und verkette sie dann und versuche dann, diese verkettete .ts-Datei zu codieren. Die Dateien sind h264 und aac-codiert und ich hoffe, dass die Qualität gleich bleibt oder dem Original so nahe wie möglich kommt.

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

Leider wird beim Codieren die folgende Fehlermeldung von ffmpeg angezeigt:

[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

Dies geschieht ungefähr in der Mitte der Codierung, was mich denken lässt, dass Sie nicht zwei .ts-Dateien zusammenfassen können, damit es funktioniert.

FFmpeg verfügt über drei Verkettungsmethoden:

1. Concat-Videofilter

Verwenden Sie diese Methode, wenn Ihre Eingaben nicht dieselben Parameter (Breite, Höhe usw.) oder dieselben Formate / Codecs haben oder wenn Sie eine Filterung durchführen möchten. (Sie können nur die nicht übereinstimmenden Eingänge neu codieren, sodass sie denselben Codec und andere Parameter verwenden. Verwenden Sie dann den Concat-Demuxer, um eine erneute Codierung der anderen Eingänge zu vermeiden.)

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

Beachten Sie, dass diese Methode eine Neucodierung durchführt.

2. Concat Demuxer

Verwenden Sie diese Methode, wenn Sie eine Neucodierung vermeiden möchten und Ihr Format keine Verkettung auf Dateiebene unterstützt (die meisten von allgemeinen Benutzern verwendeten Dateien unterstützen keine Verkettung auf Dateiebene).

$ 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

Für 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-Protokoll

Verwenden Sie diese Methode mit Formaten, die die Verkettung auf Dateiebene unterstützen (MPEG-1, MPEG-2 PS, DV). Sie nicht mit MP4 verwenden.

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

Diese Methode funktioniert aufgrund der Art dieser Formate und der vereinfachten Verkettung mit dieser Methode nicht für viele Formate, einschließlich MP4.

Wenn Sie sich nicht sicher sind, welche Methode Sie verwenden sollen, versuchen Sie es mit dem concat-Demuxer.

Siehe auch

• FFmpeg FAQ: Wie kann ich Videodateien verbinden?
• FFmpeg Wiki: So verketten Sie Mediendateien (verbinden, zusammenführen)

FÜR MP4-DATEIEN

Für MP4- Dateien (die ich von DailyMotion.com erhalten habe: eine 50-minütige TV-Episode, die nur in drei Teilen als drei MP4-Videodateien heruntergeladen werden kann) war das Folgende eine effektive Lösung für Windows 7 und beinhaltet KEINE Neucodierung der Dateien.

Ich habe die Dateien (als file1.mp4 , file2.mp4 , file3.mp4 ) so umbenannt, dass die Teile in der richtigen Reihenfolge für die Anzeige der gesamten TV-Episode waren.

Dann habe ich eine einfache Batch-Datei (concat.bat) mit folgendem Inhalt erstellt:

:: 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

Die Batch-Datei und ffmpeg.exe müssen sich beide im selben Ordner wie die zu verbindenden MP4-Dateien befinden. Führen Sie dann die Batchdatei aus. Die Ausführung dauert normalerweise weniger als zehn Sekunden.
.

Nachtrag (21.10.2018) -

Wenn Sie nach einer Methode gesucht haben, mit der Sie alle mp4-Dateien im aktuellen Ordner ohne viel erneutes Eingeben angeben können, versuchen Sie dies stattdessen in Ihrer Windows- Batchdatei ( MUSS die Option -safe 0 enthalten ):

:: 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

Dies funktioniert unter Windows 7 in einer Batchdatei. Versuchen Sie nicht , es in der Befehlszeile zu verwenden, da es nur in einer Batch-Datei funktioniert!

Hier ist eine schnelle (dauert weniger als 1 Minute) und verlustfreie Möglichkeit, dies zu tun, ohne Zwischendateien zu benötigen:

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

Das "ls" enthält die Dateien, die verbunden werden sollen. Das "Perl" erstellt die Verkettungsdatei im laufenden Betrieb in einer Pipe. Der Teil "-i -" weist ffmpeg an, aus der Pipe zu lesen

(Hinweis: Meine Dateien enthielten keine Leerzeichen oder seltsamen Elemente. Wenn Sie diese Idee mit "harten" Dateien ausführen möchten, benötigen Sie eine entsprechende Shell-Escape-Funktion.)

für MP4-Dateien:

Wenn es sich nicht genau um MP4-Dateien handelt (100% gleicher Codec, gleiche Auflösung, gleicher Typ), müssen Sie sie zunächst in Zwischen-Streams umcodieren:

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

HINWEIS! : Die Ausgabe erfolgt wie die erste Datei (und nicht wie eine zweite).

Ich habe versucht, drei .mp3Audiodateien zu einer .m4aDatei zu verketten, und dieser Befehl ffmpeg funktioniert.

Eingabebefehl:

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

Bedeutungen von: "-filter_complex concat = n = 3: v = 0: a = 1" :

concat bedeutet, dass Sie die Funktion zum Verketten (Verbinden) von Medien verwenden.
n bedeutet, die Gesamtzahl der Eingabedateien zu bestätigen.
v bedeutet hat Video ? benutze 0 = kein Video, 1 = enthält Video.
ein Mittel hat Audio ? Verwenden Sie 0 = kein Audio, 1 = Audio enthalten.
-f bedeutet erzwingen, dass das Dateiformat festgelegt wird (um alle unterstützten Formate anzuzeigen , verwenden Sie ffmpeg -formats)
-vn bedeutet, dass Video deaktiviert wird (und auch -anAudio deaktiviert wird, wenn dies nicht gewünscht wird)
-y bedeutet, dass Ausgabedateien überschrieben werden (falls die Ausgabedatei bereits vorhanden ist).

Für weitere Informationen: Verwenden Sie ffmpeg -h full alle Optionen drucken (einschließlich aller format- und codecspezifischen Optionen, sehr lang).

Am Ende habe ich mpg als Zwischenformat verwendet und es hat funktioniert (HINWEIS: Dies ist ein gefährliches Beispiel, -qscale 0 wird das Video neu codieren ...)

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

Eine ausführliche Dokumentation zu verschiedenen Arten der Verkettung in ffmpeg finden Sie hier .

Sie können den 'Concat-Filter' für eine schnelle Verkettung verwenden.

Es führt eine Neucodierung durch. Diese Option ist am besten geeignet, wenn die Eingänge unterschiedliche Video- / Audioformate haben.

Zum Verketten von 2 Dateien:

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

Zum Verketten von 3 Dateien:

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

Dies funktioniert sowohl für denselben als auch für mehrere Eingabedateitypen.

Ich habe festgestellt, dass der Pipe-Operator bei mir nicht funktioniert hat, als Option 3 verwendet wurde, um mehrere MP4s auf einem Mac in der akzeptierten Antwort zu speichern.

Der folgende Einzeiler funktioniert auf einem Mac (High Sierra), um MP3s zu verketten, ohne dass eine zwischengeschaltete Dateierstellung erforderlich ist.

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

Hier 2 reine Bash-Lösungen nur mit ffmpegund nicht mit

• eine Zwischendatei
• Perl, Python oder Javascript

Einzeilige Lösung mit 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

Funktion, die 0 oder 2+ Argumente akzeptiert

#######################################
# 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
}

Hinweis: Ich habe einige Lösungen in diesem Thread ausprobiert und keine hat mich zufrieden gestellt

Basierend auf den Antworten von Rogerdpack und Ed999 habe ich meine .sh-Version erstellt

#!/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

Es verbindet alle *.mp4Dateien im aktuellen Ordner injoined-out.mp4

auf Mac getestet.

Die resultierende Dateigröße ist die genaue Summe meiner 60 getesteten Dateien. Sollte kein Verlust sein. Genau das, was ich brauchte

das hat bei mir funktioniert (unter Windows)

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

ein Beispiel...

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

Python

Verwenden Sie Python-Code, um mit so vielen mp4-Dateien in einem Ordner zu arbeiten (installieren Sie Python von python.org, kopieren Sie diesen Code, fügen Sie ihn ein, speichern Sie ihn in einer Datei namens mp4.py und führen Sie ihn aus dem cmd aus, der im Ordner mit Python geöffnet ist mp4.py und alle mp4 im Ordner werden verkettet)

import glob
import os

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

Version 2 mit Python

Aus meinem Beitrag in meinem Blog entnommen , mache ich das in Python so:

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()

.mp4Ich fand, dass es für Dateien besser und schneller funktioniert, das OpenSource-Befehlszeilentool zu verwenden : mp4box. Dann können Sie es folgendermaßen verwenden:

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

Laden Sie es hier für die meisten Plattformen herunter: https://gpac.wp.imt.fr/mp4box/

Hier ist ein Skript, das ich erstellt habe, um mehrere GoPro-MP4s zu einem 720p-MP4 zu verketten. Hoffe es ist hilfreich.

#!/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}

Aus der Dokumentation hier: https://trac.ffmpeg.org/wiki/Concatenate

Wenn Sie über MP4-Dateien verfügen, können diese verlustfrei verkettet werden, indem Sie sie zuerst in MPEG-2-Transportströme umcodieren. Mit H.264-Video und AAC-Audio kann Folgendes verwendet werden:

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

Dieser Ansatz funktioniert auf allen Plattformen.

Ich brauchte die Fähigkeit, dies in einem plattformübergreifenden Skript zu kapseln, also habe ich fluent-ffmpegdie folgende Lösung verwendet und gefunden:

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

Zusammenführen aller mp4-Dateien aus dem aktuellen Verzeichnis

Ich persönlich mag es nicht, externe Dateien zu erstellen, die ich später löschen muss, daher folgte meine Lösung, die eine Auflistung der Dateinummern enthält (wie 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

Nach verschiedenen Versuchen unten funktionierte das Skript für mich unter 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

Hier erstellen die ersten beiden Zeilen eine Textdatei temp.txt mit folgendem Inhalt

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

Die 3. und 4. Zeile prüfen, ob ffmpeg im Pfad verfügbar ist, und erstellen die Datei "join.mp4".

Die wichtigsten Unterschiede zu anderen Antworten sind nachstehend aufgeführt

usage  of -bsf:v hevc_mp4toannexb -an

Für meine oben funktionierende MP4-Datei müssen Sie möglicherweise andere Alternativen wie die folgenden verwenden, abhängig von Ihrer Videokodierung.

h264_mp4toannexb

Alle möglichen Bitstream-Filter finden Sie unter https://ffmpeg.org/ffmpeg-bitstream-filters.html

Hier ist meine Methode zum Verbinden eines Verzeichnisses voller MP4-Dateien mithilfe der Befehlssubstitution und des Concat-Videofilters (dieser wird neu codiert) 17 Dateien auf einen Schlag verbunden):

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

Hinweis: Dieser Befehl verknüpft Ihre Dateien in der Reihenfolge, in der sie benannt sind (dh in derselben Reihenfolge, in der sie beim Ausführen angezeigt werden ls *.mp4). In meinem Fall hatten sie jeweils eine Titelnummer, sodass es hervorragend funktioniert hat.

Das hier beschriebene Concat-Protokoll; https://trac.ffmpeg.org/wiki/Concatenate#protocol

Bei Implementierung mit Named Pipes, um Zwischendateien zu vermeiden

Ist sehr schnell (lesen: sofort), hat keine Frames gelöscht und funktioniert gut.

Denken Sie daran, die genannten Pipe-Dateien zu löschen und zu überprüfen, ob es sich bei dem Video um H264 und AAC handelt, was Sie nur tun können ffmpeg -i filename.mp4(überprüfen Sie, ob h264 und aac erwähnt wurden).

Die akzeptierte Antwort in Form eines wiederverwendbaren PowerShell-Skripts

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
}