Sto cercando di concatenare due file mp4 usando ffmpeg. Ho bisogno che questo sia un processo automatico, quindi perché ho scelto ffmpeg. Sto convertendo i due file in file .ts e quindi concatenandoli e quindi provando a codificare quel file .ts concesso. I file sono codificati in h264 e aac e spero di mantenere la qualità uguale o il più vicino possibile all'originale.

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

Sfortunatamente sto ricevendo il seguente messaggio di errore che ritorna da ffmpeg durante la codifica:

[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

Questo succede a metà della codifica, il che mi fa pensare che non puoi concatenare due file .ts insieme e farlo funzionare.

FFmpeg ha tre metodi di concatenazione:

1. concat filtro video

Utilizzare questo metodo se gli input non hanno gli stessi parametri (larghezza, altezza, ecc.) O se non sono gli stessi formati / codec o se si desidera eseguire qualsiasi filtro. (È possibile ricodificare solo gli input che non corrispondono in modo che condividano lo stesso codec e altri parametri, quindi utilizzare il demuxer concat per evitare la ricodifica degli altri input).

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

Si noti che questo metodo esegue una ricodifica.

2. concat demuxer

Utilizzare questo metodo quando si desidera evitare una ricodifica e il formato non supporta la concatenazione a livello di file (la maggior parte dei file utilizzati dagli utenti generici non supporta la concatenazione a livello di file).

$ 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

Per 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. protocollo concat

Utilizzare questo metodo con formati che supportano la concatenazione a livello di file (MPEG-1, MPEG-2 PS, DV). Da non utilizzare con MP4.

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

Questo metodo non funziona per molti formati, incluso MP4, a causa della natura di questi formati e della concatenazione semplicistica eseguita da questo metodo.

In caso di dubbi sul metodo da utilizzare, provare il demuxer concat.

Vedi anche

• Domande frequenti su FFmpeg: come posso unire file video?
• FFmpeg Wiki: come concatenare (unire, unire) i file multimediali

PER FILE MP4

Per i file .mp4 (che ho ottenuto da DailyMotion.com: un episodio televisivo di 50 minuti, scaricabile solo in tre parti, come tre file video .mp4), la seguente era una soluzione efficace per Windows 7 e NON comporta la ricodifica del File.

Ho rinominato i file (come file1.mp4 , file2.mp4 , file3.mp4 ) in modo tale che le parti fossero nell'ordine corretto per visualizzare l'episodio TV completo.

Quindi ho creato un semplice file batch (concat.bat), con i seguenti contenuti:

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

Il file batch e ffmpeg.exe devono essere entrambi inseriti nella stessa cartella dei file .mp4 da unire. Quindi eseguire il file batch. In genere sono necessari meno di dieci secondi per l'esecuzione.
.

Addendum (2018/10/21) -

Se quello che stavi cercando è un metodo per specificare tutti i file mp4 nella cartella corrente senza molta riscrittura, prova invece questo nel tuo file batch di Windows ( DEVE includere l'opzione -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

Funziona su Windows 7, in un file batch. Non provare a usarlo dalla riga di comando, perché funziona solo in un file batch!

Ecco un modo veloce (richiede meno di 1 minuto) e senza perdite per farlo senza la necessità di file intermedi:

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

"Ls" contiene i file da unire Il "perl" crea il file di concatenazione al volo in una pipe La parte "-i -" dice a ffmpeg di leggere dalla pipe

(nota - i miei file non avevano spazi o cose strane in essi - avrai bisogno di una fuga di shell appropriata se vuoi fare questa idea con file "difficili").

per file MP4:

Se non sono esattamente gli stessi file MP4 (100% stesso codec, stessa risoluzione, stesso tipo), all'inizio devi transcodificarli in flussi intermedi:

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

NOTA! : L'output sarà come il primo file (e non un secondo)

Stavo cercando di concatenare tre .mp3file audio in un unico .m4afile e questo comando ffmpeg funziona.

Comando di input:

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

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

concat significa utilizzare la funzione concatenata (unione) dei media.
n significa confermare il conteggio totale dei file di input.
v significa che ha un video ? usa 0 = nessun video, 1 = contiene video.
un mezzo ha l'audio ? usa 0 = nessun audio, 1 = contiene audio.
-f significa forzare il formato del file impostato (per visualizzare tutti i formati supportati, utilizzare ffmpeg -formats)
-vn significa disabilitare il video (e -andisabiliterebbe anche l'audio se non desiderato)
-y significa sovrascrivere i file di output (se il file di output esiste già).

Per maggiori informazioni: usa ffmpeg -h full stampa tutte le opzioni (incluse tutte le opzioni specifiche per formato e codec, molto lunghe)

Ho finito per usare mpg come formato intermedio e ha funzionato (NOTA questo è un esempio pericoloso, -qscale 0 ricodificherà il video ...)

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

La documentazione dettagliata sui vari modi di concatenazione in ffmpeg è disponibile qui .

Puoi usare 'Filtro Concat' per una concatenazione rapida.

Esegue una ricodifica. Questa opzione è ottimale quando gli ingressi hanno formati video / audio diversi.

Per concatenare 2 file:

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

Per concatenare 3 file:

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

Questo funziona per tipi di file di input uguali e multipli.

Ho scoperto che l'operatore di pipe non ha funzionato per me quando ho usato l'opzione 3 per concatenare diversi MP4 su un Mac nella risposta accettata.

Il seguente one-liner funziona su un Mac (High Sierra) per concatenare mp4, senza la necessità di creare file intermedi.

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

Qui 2 soluzioni pure bash che usano solo ffmpege non usando

• un file intermedio
• perl, python né javascript

Utilizzo di una soluzione di rivestimento 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

Funzione che accetta 0 o 2+ argomenti

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

Nota: ho provato alcune soluzioni in questo thread e nessuno mi ha soddisfatto

sulla base delle risposte di rogerdpack e Ed999, ho creato la mia versione .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

unisce tutti i *.mp4file nella cartella corrente injoined-out.mp4

testato su mac.

la dimensione del file risultante è la somma esatta dei miei 60 file testati. Non dovrebbe esserci alcuna perdita. Proprio quello di cui avevo bisogno

questo ha funzionato per me (su windows)

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

un esempio...

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

Pitone

Usando un po 'di codice Python per farlo con altrettanti mp4 presenti in una cartella (installa python da python.org, copia e incolla e salva questo codice in un file chiamato mp4.py ed eseguilo dal cmd aperto nella cartella con python mp4.py e tutti gli mp4 nella cartella verranno concatenati)

import glob
import os

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

Versione 2 con Python

Tratto dal mio post sul mio blog , ecco come lo faccio in 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()

Per .mp4i file, ho trovato che funziona meglio e più velocemente di utilizzare lo strumento da riga di comando opensource: mp4box. Quindi puoi usarlo in questo modo:

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

Scaricalo qui per la maggior parte delle piattaforme: https://gpac.wp.imt.fr/mp4box/

Ecco uno script che ho creato per concatenare diversi mp4 di GoPro in un mp4 a 720p. Spero sia di aiuto.

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

Dalla documentazione qui: https://trac.ffmpeg.org/wiki/Concatenate

Se si dispone di file MP4, questi potrebbero essere concatenati senza perdita di dati, prima di transcodificarli in flussi di trasporto MPEG-2. Con video H.264 e audio AAC, è possibile utilizzare:

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

Questo approccio funziona su tutte le piattaforme.

Avevo bisogno della capacità di incapsulare questo in uno script multipiattaforma, quindi ho usato fluent-ffmpege trovato la seguente soluzione:

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

Unendo tutti i file mp4 dalla directory corrente

Personalmente mi piace non creare file esterni che devo eliminare in seguito, quindi la mia soluzione stava seguendo che include l'elenco di numerazione dei file (come 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

Dopo vari tentativi di seguito, lo script ha funzionato per me su 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

Qui le prime due righe creano un file di testo temp.txt che ha il seguente contenuto

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

3a, 4a riga controlla se ffmpeg è disponibile nel percorso e crea il "join.mp4"

Le principali differenze rispetto alle altre risposte sono le seguenti

usage  of -bsf:v hevc_mp4toannexb -an

per il mio file mp4 sopra funzionato, potrebbe essere necessario utilizzare altre alternative come di seguito a seconda della codifica video.

h264_mp4toannexb

Tutti questi possibili filtri Bitstream sono disponibili all'indirizzo https://ffmpeg.org/ffmpeg-bitstream-filters.html

Ecco il mio metodo per unire una directory piena di file MP4 usando la sostituzione dei comandi e il filtro video concat (questo ricodificherà) - ho pensato che qualcun altro avrebbe avuto un po 'di utile da questo one-liner, specialmente se hai molti file (ho solo ha unito 17 file in un colpo solo):

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

NB questo comando unisce i tuoi file nell'ordine in cui sono stati nominati (cioè nello stesso ordine in cui sono presentati se corri ls *.mp4) - nel mio caso, avevano ciascuno un numero di traccia, quindi ha funzionato alla grande.

Il protocollo concat qui descritto; https://trac.ffmpeg.org/wiki/Concatenate#protocol

Se implementato utilizzando pipe denominate per evitare file intermedi

È molto veloce (leggi: istantaneo), non ha rilasciato frame e funziona bene.

Ricorda di eliminare i file di pipe con nome e ricorda di verificare se il video è H264 e AAC che puoi fare solo con ffmpeg -i filename.mp4(controlla le menzioni h264 e aac)

La risposta accettata sotto forma di script PowerShell riutilizzabili

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
}