Página 1 de 2 12 ÚltimoÚltimo
Resultados 1 al 10 de 19

Tema: [MANUAL] FFMPEG ese gran desconocido.

  1. #1
    El señor de los forillos
    Edad
    28
    Mensajes
    2,852

    Predeterminado [MANUAL] FFMPEG ese gran desconocido.

    Recientemente he tenido que leer muchísima información debido a un proyecto de vídeotutoriales que tengo entre manos, y como me siento con ganas y tengo algo de tiempo, me he decidido a escribir este manual que podremos utilizar todos para explotar esa fantástica herramienta que tenemos a nuestro alcance.

    [objetivos del manual]

    • Aprender a utilizar a fondo FFMPEG
    • Aprender a aplicar watermarks a nuestros vídeos
    • Automatizar la creación de nuestros vídeos. Desde la creación, hasta su publicación en youtube

    [Material necesario]

    • svn
    • imagemagick
    • gimp
    • googlecl
    • Ganas de aprender

    [Material del que os tenéis que deshacer]

    • Miedo a utilizar la consola de comandos. Es una herramienta muy potente. Aprovechemoslo.

    Lo primero: La instalación de las herramientas.

    Como buenos trabajadores que somos vamos a necesitar que nuestro taller (sistema) tenga las herramientas (programas) necesarias.


    • svn: nos servirá para bajar la última versión disponible de ffmpeg

    Instalación: simplemente instalaremos el paquete svn

    Una vez que hayamos instalado svn ejecutaremos los siguiente para obtener ffmpeg:
    Código:
     svn checkout svn://svn.ffmpeg.org/ffmpeg/trunk ffmpeg
    esto bajará la última versión disponible de las fuentes de ffmpeg.
    A continuación nos cambiamos al directorio ffmpeg:
    Código:
     cd ffmpeg
    Una vez dentro del directorio hemos de configurar las opciones que queremos que tenga ffmpeg. Yo os aconsejo que las tenga todas, para ello ejecutamos lo siguiente:
    Código:
    ./configure --enable-gpl --enable-libmp3lame --enable-libvorbis --enable-libfaac --enable-libxvid --enable-libx264 --enable-libvpx --enable-libtheora --enable-postproc --enable-shared --enable-pthreads --enable-x11grab --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libschroedinger --enable-libopenjpeg --enable-version3 --enable-nonfree --enable-runtime-cpudetect
    A continuación ejecutamos:
    Código:
     make -jNumero_Nucleos+1
    Dónde numero de nucleos + 1 como dice su nombre, es el número de núcleos de tu procesador + 1, si tienes un dual core entonces ahí pondrás 3, si tienes quadcore, entonces pondrás 5.

    Esto permite que la compilación del programa utilice todos los núcleos del sistema, lo que hará que compilación sea mas rápida.

    Después, como administrador ejecutas:
    Código:
     make install
    Para instalar ffmpeg.

    Tras esto, FFMPEG quedará instalado y listo para poder usarse.
    • imagemagick

    Instalamos el paquete imagemagick, lo necesitaremos para aplicar marcas de agua a nuestros vídeos.


    • Gimp

    O cualquier otro programa de creación/edición de imágenes. Lo necesitaremos para crear nuestra marca de agua.
    • Googlecl

    Este me ha llevado tiempo encontrarlo, pero es extremadamente útil pues nos va a permitir subir vídeos a youtube desde la línea de comandos.

    Una vez que tenemos las herramientas. Pasamos a lo que realmente nos interesa. Aprender a utilizar ffmpeg.


    • ¿Cómo cambiar el formato de los vídeos?

    ¿Cuántas veces nos ha pasado que tenemos un vídeo que queremos subir a youtube y no hemos podido porque era muy pesado? ¿ o no queremos esperar media vida esperando a subir 2 gigas de vídeo con nuestras maravillosas conexiones?

    La solución pasa por recodificar el vídeo a otro formato que comprima el vídeo y que no trastoque demasiado su calidad. ¿Cómo conseguir esto? desde la versión 0.6 podemos utilizar el contenedor .webm con vídeo codificado en VP8 y audio con theora ogg vorbis. Todo de código abierto.

    Esto nos comprimirá el vídeo haciendo que ocupe menos, y manteniendo la calidad del vídeo. ¿Cómo hacerlo?
    Código:
     ffmpeg -i Video_a_convertir -sameq Video_Convertido.webm
    Tan simple como eso, con idicarle la extensión .webm FFMPEG ya sabe qué utilizar, y utilizará VP8 para video y vorbis para audio.

    Explicación de opciones:

    • -i ---> Indica el Vídeo fuente original
    • -sameq ---> el vídeo de salida conserva la calidad del original (importante, seleccionar siempre) para evitar pérdidas.

    • Mas formatos de audio, vídeo y contenedores

    Un vídeo no es mas que una sucesión de imágenes con una o varias pistas de audio, por lo que, para tener un único archivo multimedia necesitamos meter las imágenes y el audio en un contenedor.


    • Formatos de vídeo

    Actualmente hay muchos, son los que codifican las imágenes. A día de hoy los que mas nos interesan son los siguientes:

    • mpeg4 --> admite aceleración por hardware
    • h264 ---> admite aceleración por hardware (cerrado)
    • x264 ---> igual que h264 pero abierto
    • VP8 --> alta calidad de código abierto (nuevo)
    • theora --> alta compresión de código abierto

    Para forzar la utilización de un tipo de códec de vídeo utilizaremos la siguiente opción:
    Código:
     -vcodec Codec_que_queremos
    Si no sabemos qué códec utilizar, no pondremos nada, o pondremos:
    Código:
     -vcodec copy
    que utilizará el mismo códec que el video fuente.
    • Formatos de audio

    Al igual que los formatos de vídeo, tenemos bastantes formatos de audio. ¿Cuáles nos interesarán mas a nosotros:

    • FLAC ---> no tiene pérdidas, admite multicanal, código libre
    • AAC ---> similar a FLAC pero no se si es libre.
    • ogg --> cuando queramos comprimir el audio, es el mas recomendado, código abierto.

    Para forzar el uso de un determinado códec utilizaremos la siguiente opción:
    Código:
     -acodec codec
    Si no sabemos cual usar, no pondremos nada, o usaremos la opción
    Código:
     -acodec copy
    • Contendedores
    Es dónde "estarán metidos" el vídeo y el audio. ¿Cuántos hay? Bastantes también, pero a día de hoy los mas relevantes son:

    • mkv--> admite FULLHD y es de código abierto
    • mp4--> admite FULLDH
    • webm --> admite FULLHD y es el ideal para vp8

    Hasta no hace mucho, el contenedor flv era muy utilizado gracias a youtube, pero desde que youtube permite subir vídeos en .mkv, .mp4, y, recientemente en .webm, no tiene sentido que se siga utlizando .flv.

    ¿Cómo escoger contenedor? pues es tan fácil como poner la extensión de archivo adecuada, que quieres mkv, pues el fichero de salida será: video-de-salida.mkv
    Y así con todos. Muy simple.

    • Cambiar la resolución de un vídeo:

    Para cambiar a la resolución deseada basta con pasar la opción
    Código:
     -s [ancho]x[alto]
    en pixels

    Muchas veces querremos agrandar un vídeo. Por ejemplo, yo que tengo un monitor de 17" TFT de resolución 1280x1024 formato 5:4 me gusta que mis tutoriales estén disponibles en fullHD, de modo que para conseguirlo sería:
    Código:
    ffmpeg -i Video_Entrada -sameq -s 1920x1080 -aspect 16:9 video_salida
    Dónde la opción -aspect detalla que la salida estará en formato panorámico.

    Esto lo que hará será estirar la imagen con una calidad bastante buena y apenas se nota pérdida de calidad, en este caso. La pérdida de calidad se sitúa en el 10% que al ojo humano no se nota, lo que notaremos será que está un poco estirado. Pero la calidad será estupenda.

    Para minimizar la pérdida de calidad, a mi me gusta utilizar esta opción:
    Código:
    -pix_fmt rgb48le
    esto lo que hace es cambiar el formato del pixel, del original predeterminado que contiene solo 16 bits de información, por otro que contiene 48 bits de información.

    Evidentemente, si tenemos un vídeo cuya resolución original es de 320x240, si pretendemos pasarlo a 1080 la pérdida de calidad va a ser mas que notable, a pesar de no haberlo probado personalmente, pero creo que me puedo aventurar.
    • Convertir un vídeo en imágenes

    con este comando lograremos conseguirlo:
    Código:
     ffmpeg -i Video -sameq -r 25 fotograma%d.png
    explicación:

    • -r 25 establece los fotogramas por segundo, sacara 25 imagenes por segundo (podemos cambiar el valor a nuestro gusto)
    • fotograma%d.png la salida será fotograma1, fotograma2...., %d muestra una cuenta ascendente.
    • Convertir secuencia de imágenes en vídeo

    Con el comando:
    Código:
    ffmpeg -i fotograma%d.png -sameq video.mkv
    Tendremos un video hecho con imágenes pero sin audio.
    Inconveniente Necesitaremos que las imágenes estén nombradas como fotograma1 fotograma2 ... en cuenta ascendente. No necesariamente ha de llamarse fotograma, puede ser 1 2 3 4 5 ... en ese caso, en lugar de hacer fotograma%d.png, hacemos:
    Código:
     %d.png
    • Silenciar un vídeo

    Con el siguiente comando, conseguiremos tener un vídeo sin sonido:
    Código:
     ffmpeg -i VideoEntrada -sameq -an VideoSalida
    • Extraer audio de un vídeo

    Si queremos extraer el audio para modificarlo, y luego reinsertarlo, entonces os recomiendo que lo extraigáis en FLAC para que no haya pérdida de calidad:
    Código:
     ffmpeg -i video -sameq AudioVideo.flac
    Si queremos extraer el audio del videoclip que nos han prestado para ponerlo como tono del móvil:
    Código:
     ffmpeg -i Video -sameq -ab 320k audioVideo.mp3
    Explicación de opciones extras:

    • -ab --> audio bitrate, cuanto mas grande mas calidad
    • Insertar Nuevo audio a un vídeo

    Para ello debemos tener previamente un vídeo silenciado.
    Código:
     ffmpeg -i Video -i NuevoAudio -sameq VideoConNuevoAudio
    Hemos de tener en cuenta que el vídeo resultante será tan largo como lo que mas dure, es decir, si el audio es mas largo que el vídeo, tendrá la duración del audio, y viceversa.
    • Unir varios videos en uno

    Para ello necesitamos primero convertir los vídeos a mpeg. Luego haremos:
    Código:
     cat Video1 Video2....VideoN > VideoFinal
    • Acortar un video

    Para esto tenemos 2 maneras: La primera se tratar de cortar un trozo del principio, es decir, queremos que el nuevo vídeo empiece en el segundo 26 del vídeo original. Para ello:
    Código:
     ffmpeg -i VideoOrignal -sameq -ss 26 VideoFinal
    Otra opción es que queramos que el vídeo dure 10 minutos justos entonces le pasaremos la opción -t 600
    Código:
     ffmpeg -i VideoOriginal -sameq -t 600 VideoFinal


    • Grabar nuestro escritorio

    Con el siguiente comando, conseguiremos grabar nuestro escritorio mientras que trabajamos con él, además, de grabar también nuestra voz por el micrófono para ir dando instrucciones.
    Código:
     ffmpeg -async 1 -f alsa -i plughw:0,0  -f x11grab -pix_fmt rgb48le -r 25 -s [ancho]x[alto] -i :0.0 -b 25000k VideoSalida

    explicación de opciones:
    • -async 1 --> hace que el audio y el vídeo vayan sincronos
    • -f alsa --> le decimos que queremos grabar desde un dispositivo alsa
    • -i plughw:0,0 --> así es como se identifica mi micrófono, el vuestro puede variar
    • -f x11grab --> esto le indica al programa que quiere grabar la X (entorno gráfico)
    • -pix_fmt rgb48le --> simplemente utiliza un pixel que puede almacenar mas información que uno "normal"
    • -r 25 indica que se tomarán 25 imágenes por segundo
    • - [ancho]x[alto] le dice el tamaño de la imagen, no puede ser mayor que la resolución de tu monitor.
    • -i :0.0 --> esta es la pantalla de la que se va a grabar, si solo tienes una, será identificada como aquí.
    • -b 25000k le estoy indicando que quiero un bitrate de 25000k



    Y hasta aquí de momento, el uso "en bruto de ffmpeg" mas adelante os contaré como aplicar filtros, o lo mas interesante, dibujar marcos, o recortar los marcos de las películas.
    Pero pasamos a:

    Creación de nuestra watermark (marca de agua)

    Muchos os preguntaréis qué carallo es esto de la marca de agua. Os lo voy a explicar. Por desgracia para nosotros (creadores de contenido) hay muchos que se quieren aprovechar de nuestro trabajo cuando hacemos un vídeo para llevarse ellos el mérito, o llevarse las posibles ganancias.
    La marca de agua lo que nos permite es "firmar" el vídeo digitalmente de modo que siempre se va a saber que es nuestro, pues la marca es imborrable.

    Es como cuando ves una película en la televisión que aparece el símbolo de la cadena en la que la están echando.
    Nosotros nos vamos a crear nuestro propio sello que evitará que otros se aprovechen de nuestro vídeo declarándonos autores insustituibles del material.
    Esto no quiere decir que evitemos que otros usen nuestro vídeo, pero así todo el mundo sabrá quien es quien lo ha hecho.

    Para ello con gimp por ejemplo nos vamos a crear una imagen de resolución igual a la de nuestro vídeo, pero con fondo transparente. Y en ella en una esquina, o dónde mas nos guste, pondremos nuestro logo, o lo que mas os guste a vosotros.
    Consejo Debe ser lo suficientemente grande para que se vea, pero lo suficientemente pequeño para que no estorbe y estar colocado en una esquina preferiblemente.

    Una vez que la tenemos, la guardamos como imagen PNG, por ejemplo logo.png

    Después, utilizaremos el programa imagemagick para fusionar nuestro logo, con nuestro vídeo.
    Pero con esto tenemos un problema:
    Imagemagick solo permite fusionar imágenes, y una cada vez.

    El proceso es el siguiente:
    Código:
     composite -dissolve 100% -gravity south logo.png Imagen.png NuevaImagenConLogo.png
    Entonces, ¿cómo lo hacemos con nuestro vídeo?
    Fácil, vamos a extraer cada fotograma del vídeo y le vamos a aplicar a cada fotograma el logo, luego vamos a montar el vídeo de nuevo a partir de las nuevas imágenes.

    Problema: Muy bien, pero un vídeo son 25 imágenes por segundo lo que implica que un vídeo de 10 minutos de duración son 25 x 60 x 10 = 15000 imágenes.
    Aplicar a mano nuestro logo a 15000 imágenes es una barbaridad, y, por qué no decirlo, una jodida locura. Imaginemos que que ejecutarlo cada vez nos lleva 1 segundo siendo muy optimistas, tardaríamos 15000 segundos que en términos humanos son: mas de 4 horas sin parar. Y encima luego tenemos que montar el vídeo que para mas inri no tendrá sonido.

    Pero por eso Dios bajó de los cielos y creó los scripts . A continuación, os voy a dejar un script que hace lo siguiente:

    1. Extrae el audio del vídeo original
    2. Convierte el vídeo a fotogramas
    3. Procesa cada fotograma y le aplica la marca de agua
    4. muestra una cuenta de cuántas imágenes lleva hechas del total, y calcula el tanto por ciento que lleva completado
    5. Monta el video a partir de las nuevas imágenes
    6. Inserta el audio al vídeo
    7. Borra toda la basura generada, es decir, todas las imágenes.

    Y es el siguiente:

    Código:
    #!/bin/bash
    
    ffmpeg -i VIDEO -sameq Audio.flac
    ffmpeg -i VIDEO -sameq fotograma%d.png
    
    ls *.png | grep fotograma > listado
    mkdir NuevosFotogramas
    
    NUMIMAGENES=$(ls *.png | grep fotograma | wc -l)
    CONTADOR=0
    
    while read IMAGEN
    do
        PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$NUMIMAGENES" | bc )
        CONTADOR=$(echo "$CONTADOR" + 1 | bc )
        composite -dissolve 100% -gravity south logo.png "$IMAGEN" NuevosFotogramas/"$IMAGEN"
        echo "Procesadas "$CONTADOR" de "$NUMIMAGENES". "$PORCENTAJE_COMPLETADO"% Completo" 
    done < listado
    
    ffmpeg -i NuevosFotogramas/fotograma%d.png -sameq  VIDEO_CON-LOGO_NO-AUDIO.mkv
    ffmpeg -i VIDEO_CON-LOGO_NO-AUDIO.mkv -i Audio.flac -sameq VIDEO_FINAL_CON-LOGO.mkv
    
    rm -r NuevosFotogramas
    rm -f fotograma*.png
    rm -f listado
    echo "ya esta todo terminado Presiona una tecla para salir"
    read TECLA
    Tenéis que tener en cuenta que donde pone VIDEO es vuestro video original y que el logo tiene que tener la ruta de dónde se encuentre vuestro logo
    el resto no es necesario que lo toquéis.

    Para que veáis el resultado, os voy a mostrar dos vídeos
    Este primero no tiene huella digital

    Y este es el resultado tras haber aplicado la marca de agua de la forma que os he explicado


    AVISO: este proceso es bastante lento, puede demorarse fácilmente algunas horas para vídeos de una duración de 15 minutos.

    ATENCIÓN En una nueva versión del script publicada un poco mas abajo se optimiza para trabajar utilizando todos los núcleos disponibles, estando optimizado para procesadores de 4 núcleos.
    De esta forma el proceso en mi caso pasa de tardar mas de cuatro horas, a tardar una hora.

    En una futura versión se optimizará para cualquier procesador. Pero dadme tiempo.

    Y bueno, ya no me queda mas tiempo, en otro rato cuando pueda, os explico como modificar el script para que además, el propio script se encargue de colgar en vídeo en youtube sin que tengáis que hacer nada vosotros.

    Espero que os sea de utlidad




    Última edición por iqpi; 15/11/2010 a las 09:56
    http://www.linuxware.es/ Una pequeña web linuxera con artículos y videotutoriales
    Si te aburres, si tienes alguna duda que requiera rápida solución....
    >>>Entra en la sala de chat de linux de N3D<<<


  2. #2
    Cuenta inhabilitada
    Ubicación
    Under a lonely star
    Mensajes
    689

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    GRACIAS, MUCHAS GRACIAS.

    Interesante a la par que util.

  3. #3

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Muy bueno iqpi.

    solo una cosita, en pruebas que hice de compilación hace ya tiempo con un quad-core encontré que la opción más rápida es -jNum_cores. Probé con 1 más, 2 más, 3 más y 4 más y aunque las diferencias eran pequeñas cuando añadias mas hilos, tardabas más. Tener un hilo por núcleo era lo más rápido. Esto tiene lógica, ya que al tener más hilos que núcleos debe andar cerrando uno y abriendo otro, con lo cual pierde algo de tiempo.
    Para resolver dudas de Linux que no aclares aquí de forma más fluída puedes ingresar en irc a la sala n3d-linux. Más información en este hilo:
    http://foro.noticias3d.com/vbulletin...d.php?t=367711

    La máquina: Athlon II X4 620 + Gigabyte 785GMT-UD2H + 4GB DDR3 + SSD OCZ Vertex 2 60GB
    Lo mueve: ArchLinux x86_64 + Openbox

  4. #4
    El señor de los forillos
    Edad
    28
    Mensajes
    2,852

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Cita Iniciado por Viper_Scull Ver mensaje
    Muy bueno iqpi.

    solo una cosita, en pruebas que hice de compilación hace ya tiempo con un quad-core encontré que la opción más rápida es -jNum_cores. Probé con 1 más, 2 más, 3 más y 4 más y aunque las diferencias eran pequeñas cuando añadias mas hilos, tardabas más. Tener un hilo por núcleo era lo más rápido. Esto tiene lógica, ya que al tener más hilos que núcleos debe andar cerrando uno y abriendo otro, con lo cual pierde algo de tiempo.

    Yo la verdad es que tampoco he entendido nunca el porqué se recomienda siempre utilizar -jNum_Nucleos + 1, pues pensaba igual que tu, pero tampoco me puse a mirar diferencias.

    Quizás ese argumento fuera válido antaño como la "regla" de poner una swap del doble del tamaño de la memoria ram xD

    Por cierto me alegro que os sea de utilidad, y ahora que lo releo, veo que me he olvidado de cómo poner para grabar nuestro propio escritorio y a la vez grabar el audio desde el micro.
    Bueno, pero eso ya lo haré mañana cuando pueda.
    http://www.linuxware.es/ Una pequeña web linuxera con artículos y videotutoriales
    Si te aburres, si tienes alguna duda que requiera rápida solución....
    >>>Entra en la sala de chat de linux de N3D<<<


  5. #5
    El señor de los forillos Avatar de el_angel_caido
    Ubicación
    En un lugar de Asturias de cuyo nombre no quiero acordarme...
    Edad
    42
    Mensajes
    4,684

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Hola.

    Si iqpi me lo permite, y para aquellos que les da miedo la consola, aunque en el caso del ffmpeg ésta es más versátil y potente, pongo algunos GUI para el ffmpeg:

    - WinFF

    - Sinthgunt

    - Hyper Video Converter

    Hasta donde se (sólo he usado los dos primeros) todos ellos permiten personalizar los parámetros del mismo modo (o parecido) a como se usarían en consola, aunque creo que no permiten tantas funciones como desde consola.

    Un saludo.


  6. #6
    Master Avatar de josort
    Ubicación
    En el Ramón Sánchez Pizjuán
    Mensajes
    1,533

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Pues este tutorial se queda en favoritos. Me va a ser de gran ayuda. Un gran trabajo.

    Un saludo.
    Super Flower Golden Silent Fanless 500W - Asus P6T Deluxe - Intel Xeon X5650 + Xigmatek HDT-S1283 Dark Night - 3x4GB Corsair Vengeance CL9 - PNY XLR8 GTX 760 - Asus Xonar D1 - SSD Crucial M500 120Gb - SSD SanDisk Ultra Plus 64Gb - Raptor 74Gb - Seagate 500Gb - Seagate 250Gb - Seagate 1TB - HP LP2465 - Unicomp Ultra Classic - Happy Hacking Keyboard Professional 2 - Slackware 14.2 64bits - Windows 10 Pro 64 bits
    Macbook - 4Gb DDR3 - Core 2 Duo 2,26Ghz - 250Gb - Geforce 9400M - OSX 10.12.1

  7. #7
    El señor de los forillos
    Edad
    28
    Mensajes
    2,852

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Tras mucho pensar y comerme el coco y leer mucho he conseguido un nuevo script que realiza el proceso en 4 veces menos de tiempo dado que ahora es multicore.

    Lo tengo optimizado para mi sistema que son 4 núcleos, aunque funcionará con cualquiera.
    También he añadido como grabar el escritorio.

    Lo de subirlo a youtube va a tocar esperar porque necesito una clave de desarrollador.

    El script se compone en realidad de 4 scripts, el principal, y 3 menores.
    Estoy escribiendo una versión que funcionará de forma óptima independientemente del número de cores que tengas, pero no tengo demasiado tiempo libre.
    La idea es averiguar el número total de fotogramas a procesar, averiguar los núcleos disponibles, y asignar una parte proporcional a cada procesador en diferentes hilos simultáneos, así se consigue un aumento brutal del rendimiento. Esta es una fase preliminar que funciona bien en mi ordenador.

    PRINCIPAL
    Código:
    #!/bin/bash
    
    # echo "Introduce el video al que quieres aplicar la marca de agua"
    # read VIDEO
    # 
    # ffmpeg -i "$VIDEO" -pix_fmt rgb48le -sameq -s 1920x1080 -aspect 16:9 Video-HD1080-Sin-Mosca.mkv
    # ffmpeg -i Video-HD1080-Sin-Mosca.mkv -pix_fmt rgb48le -sameq fotograma%d.png
    
    mkdir NuevosFotogramas
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    GRUPO2=$(echo "$GRUPO1"+1 | bc)
    GRUPO2_1=$(echo "$GRUPO1"*2 | bc)
    GRUPO3=$(echo "$GRUPO1"*2+1 | bc)
    GRUPO3_1=$(echo "$GRUPO1"*3 | bc)
    GRUPO4=$(echo "$GRUPO1"*3+1 | bc)
    GRUPO4_1=$(echo "$GRUPO1"*4+"$RESTO" | bc)
    
    for i in $(seq "$GRUPO1")
    do
    	ls fotograma"$i".png>> listado1
    done
    
    for i in $(seq "$GRUPO2" "$GRUPO2_1")
    do
    	ls fotograma"$i".png >> listado2
    done
    
    for i in $(seq "$GRUPO3" "$GRUPO3_1")
    do
    	ls fotograma"$i".png >> listado3
    done
    
    for i in $(seq "$GRUPO4" "$GRUPO4_1")
    do
    	ls fotograma"$i".png >> listado4
    done
    
    konsole --workdir ~/Videos/InstalarProgramasUbuntu -e ./cuerpo4
    konsole --workdir ~/Videos/InstalarProgramasUbuntu -e ./cuerpo3
    konsole --workdir ~/Videos/InstalarProgramasUbuntu -e ./cuerpo2
    
    CONTADOR=0
    
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south mosca.png "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado1
    
    echo "Esperando 300 segundos para terminar de procesar todas las imágenes" 
    sleep 300
    echo "empezando a montar los videos"
    
    ffmpeg -i NuevosFotogramas/fotograma%d.png -pix_fmt rgb48le -sameq Video-Con-Mosca-Sin-Audio.mkv
    ffmpeg -i Video-Con-Mosca-Sin-Audio.mkv -i Audo_Modificado.fla -pix_fmt rgb48le -sameq Video-FINAL-HD1080.mkv
    
    echo "He terminado colega. Presiona una tecla para salir de este infierno"
    read TECLA
    AUXILIAR1
    Código:
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south mosca.png "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado2
    AUXILIAR2
    Código:
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south mosca.png "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado3
    AUXILIAR3
    Código:
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south mosca.png "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado4
    No hace falta ser un lumbreras para ver que el código de los auxiliares es el mismo, solo que cada uno procesa las imágenes listadas en listas diferentes.

    SI alguien sabe cómo hacer esto sin la necesidad de tener que recurrir a varios scripts, se lo agradecería infinito.

    Un saludo.
    http://www.linuxware.es/ Una pequeña web linuxera con artículos y videotutoriales
    Si te aburres, si tienes alguna duda que requiera rápida solución....
    >>>Entra en la sala de chat de linux de N3D<<<


  8. #8

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Muy bueno el aporte. Muchas gracias!

  9. #9
    El señor de los forillos
    Edad
    28
    Mensajes
    2,852

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Bueno, hoy he tenido poco tiempo, y aunque la mejora del código va en progreso.
    Tengo un nuevo script que no requiere de mas scripts, pues el solito los crea.

    Lo mejor de esto es que es la base para optimizar el script para N cores.
    De momento esta es la manera rudimentaria:

    Código:
    #!/bin/bash
    
    echo "Arrastra la carpeta en la que quieres trabajar"
    read CARPETA
    echo "Introduce el video al que quieres aplicar la marca de agua"
    read VIDEO
    echo "Arrastra, o introduce la ruta de tu logo"
    read LOGO
     
    ffmpeg -i "$VIDEO" -pix_fmt rgb48le -sameq -s 1920x1080 -aspect 16:9 Video-HD1080-Sin-Mosca.mkv
    ffmpeg -i Video-HD1080-Sin-Mosca.mkv -pix_fmt rgb48le -sameq fotograma%d.png
    
    mkdir NuevosFotogramas
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    GRUPO2=$(echo "$GRUPO1"+1 | bc)
    GRUPO2_1=$(echo "$GRUPO1"*2 | bc)
    GRUPO3=$(echo "$GRUPO1"*2+1 | bc)
    GRUPO3_1=$(echo "$GRUPO1"*3 | bc)
    GRUPO4=$(echo "$GRUPO1"*3+1 | bc)
    GRUPO4_1=$(echo "$GRUPO1"*4+"$RESTO" | bc)
    
    for i in $(seq "$GRUPO1")
    do
    	ls fotograma"$i".png>> listado1
    done
    
    for i in $(seq "$GRUPO2" "$GRUPO2_1")
    do
    	ls fotograma"$i".png >> listado2
    done
    
    for i in $(seq "$GRUPO3" "$GRUPO3_1")
    do
    	ls fotograma"$i".png >> listado3
    done
    
    for i in $(seq "$GRUPO4" "$GRUPO4_1")
    do
    	ls fotograma"$i".png >> listado4
    done
    
    echo '
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south "$LOGO" "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado2' > cuerpo2
    
    echo '
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south "$LOGO" "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado3' > cuerpo3
    
    echo '
    #!/bin/bash
    
    NUM_TOTAL_IMAGENES=$(ls *.png | grep fotograma | wc -l)
    NUM_CORES=$(cat /proc/cpuinfo | grep cores | wc -l)
    let RESTO="$NUM_TOTAL_IMAGENES"%"$NUM_CORES"
    GRUPO1=$(echo "$NUM_TOTAL_IMAGENES"/"$NUM_CORES" | bc)
    CONTADOR=0
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south "$LOGO" "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado4' > cuerpo4
    
    chmod +x cuerpo2
    chmod +x cuerpo3
    chmod +x cuerpo4
    
    konsole --workdir "$CARPETA" -e ./cuerpo4
    konsole --workdir "$CARPETA" -e ./cuerpo3
    konsole --workdir "$CARPETA" -e ./cuerpo2
    
    CONTADOR=0
    
    while read IMAGEN
    do
    	CONTADOR=$(echo "$CONTADOR" + 1 | bc )
    	PORCENTAJE_COMPLETADO=$(echo "$CONTADOR"*100/"$GRUPO1" | bc )
    	composite -dissolve 100% -gravity south "$LOGO" "$IMAGEN" NuevosFotogramas/"$IMAGEN"
    	echo "Procesadas "$CONTADOR" de "$GRUPO1". "$PORCENTAJE_COMPLETADO"% completo"
    done < listado1
    
    echo "Esperando a que se terminen de procesar las imágenes" 
    wait $(pidof composite)
    echo "empezando a montar los videos"
    
    ffmpeg -i NuevosFotogramas/fotograma%d.png -pix_fmt rgb48le -sameq Video-Con-Mosca-Sin-Audio.mkv
    ffmpeg -i Video-Con-Mosca-Sin-Audio.mkv -i Nuevo_Audio.flac -pix_fmt rgb48le -sameq Video-FINAL-HD1080.mkv
    
    rm -f fotograma*.png
    rm -r NuevosFotogramas
    rm -f listado*
    rm -f cuerpo2 cuerpo3 cuerpo4
    
    echo "He terminado colega. Presiona una tecla para salir de este infierno"
    read TECLA
    Ya casi tengo la versión definitiva que estará optimizada para funcionar con tantos cores como haya disponibles.
    http://www.linuxware.es/ Una pequeña web linuxera con artículos y videotutoriales
    Si te aburres, si tienes alguna duda que requiera rápida solución....
    >>>Entra en la sala de chat de linux de N3D<<<


  10. #10
    Viciadill@
    Ubicación
    Madrid
    Mensajes
    170

    Predeterminado Re: [MANUAL] FFMPEG ese gran desconocido.

    Vaya cacao de script te ha quedado, igpi.

    Con lo sencillo que resulta en bash lanzar varios subprocesos idénticos en paralelo y esperar a que acaben. Podrías haberlo implementado de este modo:

    Código:
    #!/bin/bash
    
    echo "Arrastra la carpeta en la que quieres trabajar"
    read CARPETA
    echo "Introduce el video al que quieres aplicar la marca de agua"
    read VIDEO
    echo "Arrastra, o introduce la ruta de tu logo"
    read LOGO
    
    DIRECTORIO='NuevosFotogramas'
    IMG_PREFIX='fotograma'
    IMG_EXT='.png'
    ffmpeg -i "$VIDEO" -pix_fmt rgb48le -sameq -s 1920x1080 -aspect 16:9 Video-HD1080-Sin-Mosca.mkv
    ffmpeg -i Video-HD1080-Sin-Mosca.mkv -pix_fmt rgb48le -sameq "${IMG_PREFIX}"%d"${IMG_EXT}"
    
    mkdir "$DIRECTORIO"
    
    
    ########### Dividiendo trabajo en grupos  #####################
    NUM_CORES=$(grep -c ^processor /proc/cpuinfo)
    NUM_TOTAL_IMAGENES=$(ls "${IMG_PREFIX}"*"${IMG_EXT}" | wc -l)
    LOTE=$(( NUM_TOTAL_IMAGENES / NUM_CORES ))
    RESTO=$(( NUM_TOTAL_IMAGENES % NUM_CORES ))
    
    declare -a LOTE_INI
    declare -a LOTE_FIN
    for CORE in $(seq $NUM_CORES)
    do
        LOTE_INI[$CORE]=$(( LOTE * (CORE-1) + 1 ))
        LOTE_FIN[$CORE]=$(( LOTE * CORE ))
    done
    LOTE_FIN[$NUM_CORES]=$(( LOTE_FIN[$NUM_CORES] + RESTO ))
    ###############################################################
    
    function put_wmark ()
    {
        CONTADOR=0
        for INDEX in $(seq $1 $2)
        do
            IMAGEN="${IMG_PREFIX}${INDEX}${IMG_EXT}"
    	composite -dissolve 100% -gravity south "$LOGO" "$IMAGEN" "${DIRECTORIO}"/"${IMAGEN}"
            CONTADOR=$(( CONTADOR + 1 ))
            PORCENTAJE_COMPLETADO=$(( CONTADOR * 100 / LOTE ))
            echo "Procesadas "$CONTADOR" de "$LOTE". "$PORCENTAJE_COMPLETADO"% completo"
        done
    }
    
    for CORE in $(seq $NUM_CORES)
    do
        put_wmark ${LOTE_INI[$CORE]} ${LOTE_FIN[$CORE]} &
    done
    
    echo "Esperando a que se terminen de procesar las imágenes" 
    wait
    echo "empezando a montar los videos"
    
    ffmpeg -i "${DIRECTORIO}"/"${IMG_PREFIX}"%d"${IMG_EXT}" -pix_fmt rgb48le -sameq Video-Con-Mosca-Sin-Audio.mkv
    ffmpeg -i Video-Con-Mosca-Sin-Audio.mkv -i Nuevo_Audio.flac -pix_fmt rgb48le -sameq Video-FINAL-HD1080.mkv
    
    rm -f "${IMG_PREFIX}"*"${IMG_EXT}"
    rm -rf "$DIRECTORIO"
    
    echo "He terminado colega. Presiona una tecla para salir de este infierno"
    read TECLA

Página 1 de 2 12 ÚltimoÚltimo

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •