Próbuję połączyć dwa pliki mp4 za pomocą ffmpeg. Potrzebuję, aby był to proces automatyczny, dlatego wybrałem ffmpeg. Konwertuję dwa pliki na pliki .ts, a następnie łączę je, a następnie próbuję zakodować ten skonsolidowany plik .ts. Pliki są zakodowane w formacie h264 i aac i mam nadzieję, że jakość pozostanie taka sama lub jak najbardziej zbliżona do oryginału.

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

Niestety otrzymuję następujący komunikat o błędzie wracający z ffmpeg podczas kodowania:

[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

Dzieje się tak mniej więcej w połowie kodowania, co sprawia, że ​​myślę, że nie można połączyć dwóch plików .ts i sprawić, by działało.

FFmpeg ma trzy metody konkatenacji:

1. konkat filtr wideo

Tej metody należy użyć, jeśli dane wejściowe nie mają tych samych parametrów (szerokość, wysokość itp.) Lub nie są tymi samymi formatami / kodekami lub jeśli chcesz przeprowadzić filtrowanie. (Możesz ponownie zakodować tylko te wejścia, które nie pasują, aby miały ten sam kodek i inne parametry, a następnie użyj demuxera konkat, aby uniknąć ponownego kodowania innych wejść).

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

Zauważ, że ta metoda wykonuje ponowne kodowanie.

2. demultiplekser konkat

Użyj tej metody, jeśli chcesz uniknąć ponownego kodowania, a Twój format nie obsługuje konkatenacji na poziomie plików (większość plików używanych przez zwykłych użytkowników nie obsługuje konkatenacji na poziomie plików).

$ 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

W systemie 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. protokół konkat

Tej metody należy używać w przypadku formatów obsługujących konkatenację na poziomie plików (MPEG-1, MPEG-2 PS, DV). Czy nie korzystać z MP4.

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

Ta metoda nie działa dla wielu formatów, w tym MP4, ze względu na naturę tych formatów i uproszczoną konkatenację wykonywaną tą metodą.

Jeśli masz wątpliwości, której metody użyć, wypróbuj demuxer konkat.

Zobacz także

• FFmpeg FAQ: Jak mogę dołączyć do plików wideo?
• FFmpeg Wiki: Jak łączyć (łączyć, scalać) pliki multimedialne

DLA PLIKÓW MP4

W przypadku plików .mp4 (które otrzymałem z DailyMotion.com: 50-minutowy odcinek telewizyjny, do pobrania tylko w trzech częściach, jako trzy pliki wideo .mp4) poniższe rozwiązanie było skutecznym rozwiązaniem dla systemu Windows 7 i NIE wymaga ponownego kodowania akta.

Zmieniłem nazwy plików (na file1.mp4 , file2.mp4 , file3.mp4 ), tak aby części były w odpowiedniej kolejności do oglądania całego odcinka telewizji.

Następnie utworzyłem prosty plik wsadowy (concat.bat) o następującej treści:

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

Plik wsadowy i ffmpeg.exe , musi być zarówno umieścić w tym samym folderze co pliki .mp4 mają być połączone. Następnie uruchom plik wsadowy. Uruchomienie zajmuje zwykle mniej niż dziesięć sekund.
.

Dodatek (2018/10/21) -

Jeśli to, czego szukałeś, to metoda określania wszystkich plików mp4 w bieżącym folderze bez konieczności ponownego wpisywania, spróbuj tego w pliku wsadowym systemu Windows ( MUSI zawierać opcję -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

Działa to w systemie Windows 7 w pliku wsadowym. Nie próbuj używać go w wierszu poleceń, ponieważ działa tylko w pliku wsadowym!

Oto szybki (zajmuje mniej niż 1 minuta) i bezstratny sposób na zrobienie tego bez potrzeby używania plików pośrednich:

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

„Ls” zawiera pliki do przyłączenia „perl” tworzy plik konkatenacji w locie do potoku Część „-i -” informuje ffmpeg, aby czytał z potoku

(uwaga - w moich plikach nie było spacji ani dziwnych rzeczy - będziesz potrzebował odpowiedniego ucieczki od powłoki, jeśli chcesz zrobić ten pomysł z „twardymi” plikami).

dla plików MP4:

Jeśli nie są one dokładnie takie same (100% taki sam kodek, ta sama rozdzielczość, ten sam typ) plików MP4, najpierw musisz je przekodować do strumieni pośrednich:

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

UWAGA! : Dane wyjściowe będą jak pierwszy plik (a nie drugi)

Próbowałem połączyć trzy .mp3pliki audio w jeden.m4a plik i to polecenie ffmpeg działa.

Komenda wejściowa:

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

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

concat oznacza użycie medialnej funkcji konkatenacji (łączenia).
n oznacza całkowitą liczbę plików wejściowych.
v oznacza, że ma wideo ? użyj 0 = brak wideo, 1 = zawiera wideo.
a środek ma dźwięku ? użyj 0 = brak dźwięku, 1 = zawiera dźwięk.
-f oznacza wymuszenie ustawienia formatu pliku (aby zobaczyć wszystkie obsługiwane formaty, użyj ffmpeg -formats)
-vn oznacza wyłączenie wideo (a także -anwyłączyłby dźwięk, jeśli nie był potrzebny)
-y oznacza zastąpienie plików wyjściowych (jeśli plik wyjściowy już istnieje).

Aby uzyskać więcej informacji: użyj ffmpeg -h full opcji drukowania wszystkich opcji (w tym wszystkich opcji specyficznych dla formatu i kodeka, bardzo długo)

Skończyło się na tym, że używałem mpg jako formatu pośredniego i zadziałało (UWAGA to niebezpieczny przykład, -qscale 0 ponownie zakoduje wideo ...)

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

Szczegółową dokumentację na temat różnych sposobów łączenia w ffmpeg można znaleźć tutaj .

Możesz użyć „filtru Concat” do szybkiego połączenia.

Wykonuje ponowne kodowanie. Ta opcja jest najlepsza, gdy wejścia mają różne formaty wideo / audio.

W przypadku łączenia 2 plików:

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

W przypadku łączenia 3 plików:

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

Działa to tak samo, jak dla wielu typów plików wejściowych.

Odkryłem, że operator potoku nie działał dla mnie, gdy użyłem opcji 3 do konkatowania kilku MP4 na komputerze Mac w przyjętej odpowiedzi.

Następujący jednowierszowy działa na komputerze Mac (High Sierra) w celu połączenia plików MP4, bez konieczności tworzenia plików pośrednich.

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

Tutaj 2 rozwiązania czysto bash używają tylko ffmpegi nie używają

• plik pośredni
• perl, python ani javascript

Jednowarstwowe rozwiązanie przy użyciu 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

Funkcja, która przyjmuje argumenty 0 lub 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
}

Uwaga: wypróbowałem kilka rozwiązań w tym wątku i żadne mnie nie usatysfakcjonowało

na podstawie odpowiedzi Rogerdpack i Ed999 stworzyłem swoją wersję .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

łączy wszystkie *.mp4 pliki w bieżącym folderze wjoined-out.mp4

testowany na Mac.

wynikowy rozmiar pliku to dokładna suma moich 60 przetestowanych plików. Nie powinno być żadnej straty. Dokładnie to, czego potrzebowałem

to zadziałało dla mnie (w systemie Windows)

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

przykład...

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

Pyton

Używając kodu Pythona, aby zrobić to z tyloma plikami mp4, które znajdują się w folderze (zainstaluj python z python.org, skopiuj i wklej i zapisz ten kod w pliku o nazwie mp4.py i uruchom go z cmd otwartego w folderze z pythonem plik mp4.py i wszystkie pliki mp4 w folderze zostaną połączone)

import glob
import os

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

Wersja 2 z Python

Zaczerpnięte z mojego postu na moim blogu , tak to robię w Pythonie:

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

Dla .mp4plików, znalazłem to działa lepiej i szybciej korzystać z narzędzia wiersza polecenia opensource: mp4box. Następnie możesz użyć tego w ten sposób:

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

Pobierz go tutaj na większość platform: https://gpac.wp.imt.fr/mp4box/

Oto skrypt, który napisałem, aby połączyć kilka GoPro MP4 w 720p MP4. Mam nadzieję, że to pomoże.

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

Z dokumentacji tutaj: https://trac.ffmpeg.org/wiki/Concatenate

Jeśli masz pliki MP4, można je bezstratnie powiązać, najpierw transkodując je do strumieni transportowych MPEG-2. W przypadku wideo H.264 i audio AAC można używać:

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

To podejście działa na wszystkich platformach.

Potrzebowałem możliwości kapsułkowania tego w skrypcie wieloplatformowym, więc skorzystałem fluent-ffmpegi wymyśliłem następujące rozwiązanie:

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

Scalanie wszystkich plików MP4 z bieżącego katalogu

Osobiście lubię nie tworzyć plików zewnętrznych, które muszę później usunąć, więc moje rozwiązanie było następujące, które zawiera listę numeracji plików (np. 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

Po różnych próbach poniżej skrypt działał dla mnie w 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

Tutaj pierwsze dwa wiersze tworzą plik tekstowy temp.txt, który ma następującą treść

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

Trzeci, czwarty wiersz sprawdza, czy ffmpeg jest dostępny na ścieżce i utwórz plik „join.mp4”

Kluczowe różnice w stosunku do innych odpowiedzi są następujące

usage  of -bsf:v hevc_mp4toannexb -an

w przypadku mojego powyższego pliku mp4 może być konieczne użycie innych alternatyw, takich jak poniżej, w zależności od kodowania wideo.

h264_mp4toannexb

Wszystkie takie możliwe filtry Bitstream można znaleźć na stronie https://ffmpeg.org/ffmpeg-bitstream-filters.html

Oto moja metoda dołączania do katalogu pełnego plików MP4 przy użyciu podstawiania poleceń i filtru concat wideo (spowoduje to ponowne kodowanie) - pomyślałem, że ktoś inny skorzysta z tego jednowierszowego, szczególnie jeśli masz wiele plików (po prostu dołączył do 17 plików za jednym zamachem):

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

Uwaga: to polecenie łączy twoje pliki w kolejności, w której są nazwane (tj. W takiej samej kolejności, w jakiej są wyświetlane, jeśli uruchomisz ls *.mp4) - w moim przypadku każdy z nich miał numer ścieżki, więc działało świetnie.

Protokół concat opisany tutaj; https://trac.ffmpeg.org/wiki/Concatenate#protocol

Po wdrożeniu za pomocą nazwanych potoków, aby uniknąć plików pośrednich

Jest bardzo szybki (czytaj: natychmiastowy), nie ma opuszczonych ramek i działa dobrze.

Pamiętaj, aby usunąć nazwane pliki potoków i pamiętaj, aby sprawdzić, czy wideo to H264 i AAC, które możesz zrobić za pomocą ffmpeg -i filename.mp4(sprawdź h264 i wspomnienia)

Akceptowana odpowiedź w formie skryptu PowerShell wielokrotnego użytku

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
}