Estoy tratando de concatenar dos archivos mp4 usando ffmpeg. Necesito que este sea un proceso automático, por eso elegí ffmpeg. Estoy convirtiendo los dos archivos en archivos .ts y luego los concateno y luego intento codificar ese archivo conts. Los archivos están codificados en h264 y aac y espero mantener la calidad igual o lo más cercana posible al original.

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

Desafortunadamente, recibo el siguiente mensaje de error de ffmpeg durante la codificación:

[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

Esto sucede aproximadamente a la mitad de la codificación, lo que me hace pensar que no puedes concatenar dos archivos .ts juntos y hacer que funcione.

FFmpeg tiene tres métodos de concatenación:

1. filtro de video concat

Use este método si sus entradas no tienen los mismos parámetros (ancho, alto, etc.), o no tienen los mismos formatos / códecs, o si desea realizar algún filtrado. (Puede volver a codificar solo las entradas que no coinciden para que compartan el mismo códec y otros parámetros, luego use el demuxer concat para evitar volver a codificar las otras entradas).

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

Tenga en cuenta que este método realiza una nueva codificación.

2. demuxer concat

Utilice este método cuando desee evitar una nueva codificación y su formato no sea compatible con la concatenación de nivel de archivo (la mayoría de los archivos utilizados por los usuarios generales no son compatibles con la concatenación de nivel de archivo).

$ 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

Para 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. protocolo concat

Utilice este método con formatos que admitan la concatenación de nivel de archivo (MPEG-1, MPEG-2 PS, DV). No , no utilizar con MP4.

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

Este método no funciona para muchos formatos, incluido MP4, debido a la naturaleza de estos formatos y la concatenación simplista realizada por este método.

Si tiene dudas sobre qué método usar, pruebe el demuxer concat.

Ver también

• Preguntas frecuentes sobre FFmpeg: ¿Cómo puedo unir archivos de video?
• FFmpeg Wiki: Cómo concatenar (unir, fusionar) archivos multimedia

PARA ARCHIVOS MP4

Para los archivos .mp4 (que obtuve de DailyMotion.com: un episodio de televisión de 50 minutos, descargable solo en tres partes, como tres archivos de video .mp4), la siguiente fue una solución efectiva para Windows 7 , y NO implica volver a codificar el archivos.

Cambié el nombre de los archivos (como file1.mp4 , file2.mp4 , file3.mp4 ) de modo que las partes estaban en el orden correcto para ver el episodio de televisión completo.

Luego creé un archivo por lotes simple (concat.bat), con los siguientes contenidos:

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

El archivo por lotes , y ffmpeg.exe , deben colocarse en la misma carpeta que los archivos .mp4 para unirse. Luego ejecute el archivo por lotes. Por lo general, demorará menos de diez segundos en ejecutarse.
.

Anexo (21/10/2018) -

Si lo que estaba buscando es un método para especificar todos los archivos mp4 en la carpeta actual sin tener que volver a escribirlos, intente esto en su archivo por lotes de Windows ( DEBE incluir la opción -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

Esto funciona en Windows 7, en un archivo por lotes. ¡No intentes usarlo en la línea de comando, porque solo funciona en un archivo por lotes!

Aquí hay una manera rápida (toma menos de 1 minuto) y sin pérdidas para hacerlo sin necesidad de archivos intermedios:

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

El "ls" contiene los archivos a unir El "perl" crea el archivo de concatenación sobre la marcha en una tubería La parte "-i -" le dice a ffmpeg que lea desde la tubería

(nota: mis archivos no tenían espacios o cosas extrañas, necesitará un escape de shell apropiado si desea hacer esta idea con archivos "duros").

para archivos MP4:

Si no son exactamente los mismos archivos MP4 (100% del mismo códec, misma resolución, mismo tipo), primero debe transcodificarlos en secuencias intermedias:

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! : La salida será como el primer archivo (y no el segundo)

Estaba tratando de concatenar tres .mp3archivos de audio en un solo .m4aarchivo y este comando ffmpeg funciona.

Comando de entrada:

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

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

concat significa usar la función de concatenación de medios (unión).
n significa confirmar el recuento total de archivos de entrada.
v significa tiene video ? use 0 = sin video, 1 = contiene video.
un medio tiene audio ? use 0 = sin audio, 1 = contiene audio.
-f significa forzar el formato del archivo establecido (para ver todos los formatos compatibles, usar ffmpeg -formats)
-vn significa deshabilitar el video (y también -andeshabilitaría el audio si no se desea)
-y significa sobrescribir los archivos de salida (si el archivo de salida ya existe).

Para obtener más información: utilice ffmpeg -h full las opciones de imprimir todas (incluidas todas las opciones específicas de formato y códec, muy largas)

Terminé usando mpg como formato intermedio y funcionó (NOTA: este es un ejemplo peligroso, -qscale 0 volverá a codificar el 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 documentación detallada sobre varias formas de concatenación en ffmpeg puede ser aquí .

Puedes usar 'filtro Concat' para una concatenación rápida.

Realiza una nueva codificación. Esta opción es mejor cuando las entradas tienen diferentes formatos de video / audio.

Para concatenar 2 archivos:

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

Para concatenar 3 archivos:

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

Esto funciona para los mismos tipos de archivos de entrada y múltiples.

Encontré que el operador de tubería no funcionaba para mí cuando usaba la opción 3 para concatenar varios MP4 en una Mac en la respuesta aceptada.

El siguiente one-liner funciona en una Mac (High Sierra) para concatenar mp4s, sin necesidad de crear archivos intermedios.

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

Aquí 2 soluciones de bash puro usando solo ffmpegy no usando

• un archivo intermediario
• perl, python ni javascript

Solución de una línea usando 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

Función que toma 0 o 2+ argumentos

#######################################
# 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: había probado algunas soluciones en este hilo y ninguna me satisfizo

basado en las respuestas de rogerdpack y Ed999, he creado mi versión .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

une todos los *.mp4archivos en la carpeta actual enjoined-out.mp4

probado en mac.

el tamaño de archivo resultante es la suma exacta de mis 60 archivos probados. No debería haber ninguna pérdida. Justo lo que necesitaba

esto funcionó para mí (en windows)

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

un ejemplo...

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

Pitón

Usando algún código de Python para hacerlo con la cantidad de mp4 que hay en una carpeta (instale python desde python.org, copie y pegue y guarde este código en un archivo llamado mp4.py y ejecútelo desde el cmd abierto en la carpeta con python mp4.py y todos los mp4 en la carpeta se concatenarán)

import glob
import os

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

Versión 2 con Python

Tomado de mi publicación en mi blog , así es como lo hago en 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()

Para .mp4archivos, he encontrado que funciona mejor y más rápido de usar la herramienta de línea de comandos de código abierto: mp4box. Entonces puedes usarlo de esta manera:

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

Descárguelo aquí para la mayoría de las plataformas: https://gpac.wp.imt.fr/mp4box/

Aquí hay un script que hice para concatenar varios GoPro mp4 en un mp4 de 720p. Espero que sea de ayuda.

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

De la documentación aquí: https://trac.ffmpeg.org/wiki/Concatenate

Si tiene archivos MP4, estos podrían concatenarse sin pérdidas al transcodificarlos primero a secuencias de transporte MPEG-2. Con video H.264 y audio AAC, se puede usar lo siguiente:

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

Este enfoque funciona en todas las plataformas.

Necesitaba la capacidad de encapsular esto en un script multiplataforma, así que utilicé fluent-ffmpegla siguiente solución:

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

Fusionar todos los archivos mp4 del directorio actual

Personalmente, me gusta no crear un archivo externo que tengo que eliminar después, por lo que mi solución fue la siguiente, que incluye la lista de numeración de archivos (como 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

Después de varios intentos, el siguiente script funcionó para mí en 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

Aquí las dos primeras líneas crean un archivo de texto temp.txt que tiene el siguiente contenido

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

3ra, 4ta línea verifica si ffmpeg está disponible en la ruta y crea el "join.mp4"

Las diferencias clave de otras respuestas son las siguientes

usage  of -bsf:v hevc_mp4toannexb -an

para mi archivo mp4 anterior funcionó, es posible que deba usar otras alternativas como las siguientes, dependiendo de su codificación de video.

h264_mp4toannexb

Todos estos posibles filtros de Bitstream se pueden encontrar en https://ffmpeg.org/ffmpeg-bitstream-filters.html

Este es mi método para unirme a un directorio lleno de archivos MP4 usando la sustitución de comandos y el filtro de video concat (esto se volverá a codificar). se unieron a 17 archivos de una sola vez):

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

Nota: este comando une sus archivos en el orden en que se nombran (es decir, el mismo orden en que se presentan si ejecuta ls *.mp4); en mi caso, cada uno tenía un número de pista, por lo que funcionó muy bien.

El protocolo concat descrito aquí; https://trac.ffmpeg.org/wiki/Concatenate#protocol

Cuando se implementa utilizando canalizaciones con nombre para evitar archivos intermedios

Es muy rápido (léase: instantáneo), no tiene marcos caídos y funciona bien.

Recuerde eliminar los archivos de tubería con nombre y recuerde verificar si el video es H264 y AAC, lo que puede hacer con solo ffmpeg -i filename.mp4(verifique las menciones h264 y aac)

La respuesta aceptada en forma de script reutilizable de 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
}