Tutorial de FFmpeg na marra - Lição 1!

Tutorial de FFmpeg na marra - Lição 1!

Victor Carneiro (@vitinhocarneiro)

a.k.a. Não sabe usar o FFmpeg? Vem aprender agora!!!


Prefácio

Gostaria de dedicar esse tutorial a:

  • O grupo root@linux do Telegram,
  • Railan, meu (removido por segurança) favorito :D
  • Guitar MAN, meu baixista favorito
  • Daniele Mereb, que ama o Ubuntu :D
  • André, o capitalista
  • Adauto, que AMA Naruto assim como eu
  • Gualter Perinho, nosso açoriano favorito
  • Elias Nunes, um dos admins do blog Oficina do Tux que me deixou postar lá =D
  • Minha amiga Duda/Doda, pela piada da laranja e do prédio =D
  • E todos os outros integrantes e figuraças do grupo, e a você que está lendo e aprendendo!


Próxima lição - Codecs, Containers e Rate Control

Lição 1 - O básico do básico

O que é o FFmpeg?


O FFmpeg é um toolchain multimídia, criado inicialmente por Fabrice Bellard, e sua primeira versão foi liberada em 20 de dezembro de 2000.

O FFmpeg pode ser muito bem descrito como um canivete suíço de multimídia. Quer fazer qualquer tarefa envolvendo multimídia? FFmpeg faz. O FFmpeg é melhor descrito por minha amiga Edoarda "Duda" Vallim como: "O FFmpeg é um programa capaz de converter uma laranja pra um prédio".

Mas o propósito principal do FFmpeg é pra recodificar vídeo - ou como muitos dizem, "converter" vídeo. Foi pra isso que ele foi originalmente criado.

Hoje em dia, o FFmpeg é composto de vários módulos do projeto Libav - um fork do FFmpeg que foi mergeado de volta para o mesmo. Eles são:

  • libavutil - contém várias funções básicas usadas por todos os outros módulos.
  • libavcodec - contém bibliotecas responsáveis por codificar e interpretar (decodificar) bitstreams de vídeo/áudio/legendas.
  • libavformat - contém bibliotecas responsáveis por lidar (interpretar/escrever) com formatos de arquivo, ou melhor, containers.
  • libavdevice - contém bibliotecas responsáveis por lidar com dispositivos de entrada e saída, tais como arquivos/pipes, câmeras, placas de captura, microfones, fluxos de rede e afins.
  • libavfilter - contém bibliotecas responsáveis pelos filtros do FFmpeg.
  • libswscale - módulo responsável pelo scaler de vídeo do FFmpeg.
  • libswresample - módulo responsável pelo resampling de áudio do FFmpeg.
  • libpostproc - contém funções de pós-processamento de vídeo.

Não se preocupe, você não precisa memorizar tudo isso de imediato! Com o tempo você vai pegando o que cada módulo faz.

Como se instala essa tralha?

Vamos lá:

Instruções para usuários GNU/Linux:

Existem algumas maneiras de instalar o FFmpeg no GNU/Linux:

  1. Instalando ele do repositório oficial da sua distribuição (ou algum repositório alternativo)
  2. Usando scripts de build automático pra compilar ele do zero junto com todas as bibliotecas (recomendado, por motivos que veremos depois)
  3. Compilando ele do zero. Boa sorte!

Instruções para Windows

Pra Windows, existem as builds oficiais do Zeranoe no ffmpeg.org. Existem duas maneiras de instalar:

  1. Você simplesmente extrai o arquivo .zip e copia os três arquivos .exe pra dentro da sua pasta Windows ou sua pasta System32. É sério.
  2. Você coloca os arquivos .exe numa pasta especial e adiciona essa pasta à sua variável %PATH% do Windows.

Instruções para Mac OS X

Para OS X, existem builds do site evermeet.cx no ffmpeg.org. Você pode instalá-las como um pacote DMG.

Como se usa essa tralha?

Vamos à dura realidade (pra alguns) - FFmpeg é um programa que roda 100% em linha de comando.

Por um lado isso é ruim pra quem não tá acostumado com linha de comando, claro. Mas por outro lado isso é ótimo, por causa dos seguintes fatos:

1- O FFmpeg roda em qualquer pedaço de hardware que tenha um processador, sistema operacional e memória suficiente.

Pois é. Por ser um programa auto-contido, que não depende de bibliotecas do sistema, em qualquer coisa para a qual o GCC compile, o FFmpeg teoricamente roda. Só não espere rodar o FFmpeg com um desempenho MARA-VILHA em um PDP-11 da vida.

2- Você pode fazer o que quiser com ele. Igual brincar de Lego.

Sério, se você não usa GNU/Linux ou nunca tocou numa linha de comando, vai fazer isso agora. Vá aprender a filosofia Unix, porque é maravilhoso.

Um dos problemas de um programa que funciona com interface gráfica, na maioria das vezes é que você só pode fazer com ele exatamente o que o programador decidiu que você pode fazer. Ele não costuma ser modular ou extensível. Você não pode montar um script que usa o Adobe Media Encoder, Format Factory, ou qualquer merda dessas pra fazer um filtro que simula uma fita VHS, por exemplo.

Mas no FFmpeg... (isso é um link, vai, clica!)

Chega de enrolação.

Pra usar o FFmpeg, você basicamente roda ele passando parâmetros de linha de comando... dá Enter, e deixa rodar.

Uma linha de comando do FFmpeg pode ser dividida em 3 partes principais:

  1. O comando pra invocar o FFmpeg: ffmpeg (é claro, né, dâaaa)
  2. Um ou mais fluxos de entrada
  3. Um ou mais fluxos de saída

Vamos exemplificar isso criando o comando mais básico que se pode ter no FFmpeg:

ffmpeg -i video.avi video.mp4

Esse comando simplesmente converte um vídeo em formato AVI pra um vídeo em formato MP4, usando todos os argumentos padrão para o formato MP4.

Dividindo nas 3 principais partes:

  1. ffmpeg
  2. -i video.avi
  3. video.mp4

Simples, né? Afinal, a gente tá usando todos os argumentos padrão. Mas na maioria das vezes a gente não vai querer isso. Por quê?

Existem muitas razões, mas a questão que vamos ver mais à frente nesse curso é: Existe muita coisa na codificação de um vídeo ALÉM do formato de arquivo.

E além disso, os argumentos padrão às vezes são literalmente uma bosta. Tente rodar esse comando:

ffmpeg -i video.mp4 video.avi

E você vai ver que a qualidade do vídeo resultante vai ser UMA BELA DE UMA BOSTA. Veremos mais sobre o porquê disso na próxima lição, "Codecs, Containers e Rate Control".

E o que cada uma dessas partes leva?

A parte dos fluxos de entrada leva, dâaaa, fluxos de entrada.

Cada fluxo de entrada tem a seguinte estrutura:

  1. Argumentos do fluxo de entrada
  2. "-i (nome do fluxo de entrada)"

Por padrão, o fluxo de entrada é um arquivo ou pipe, e o nome dele é o nome do arquivo a partir do diretório atual (ou "-" pra a entrada padrão). Então, normalmente podemos omitir esses argumentos e simplesmente passar "-i nomedoarquivo.fmt".

E se houver mais de um fluxo de entrada, eles são colocados um após o outro, dessa forma:

ffmpeg -i video.m2v -f s16le -ar 44100 -i audio.s16

Neste caso, temos dois fluxos de entrada com a seguinte estrutura:

Fluxo 1

  1. ""
  2. "-i video.m2v"

Fluxo 2

  1. "-f s16le -ar 44100"
  2. "-i audio.s16"

Eu sei, ninguém entendeu nada do que significa "-f s16le -ar 44100". Relaxem, isso vocês vão aprender depois.

E o fluxo de saída?

Um fluxo de saída tem a seguinte estrutura:

  1. Argumentos do fluxo de saída
  2. Nome do fluxo de saída

É, beeeeeem parecido, né? A diferença principal é a seguinte:

  • Os argumentos dos fluxos de entrada definem como a mídia vai ser interpretada.
  • Já os argumentos dos fluxos de saída definem como a mídia vai ser processada.

Exemplo:

  • ffmpeg -i MVI_0166.TOD -f dv video-camera.dv -codec:v libx264 -crf 20 video-camera-comprimido.mp4

Fluxo 1

  1. " -f dv"
  2. " video-camera.dv"

Fluxo 2

  1. " -codec:v libx264 -crf 20"
  2. " video-camera-comprimido.mp4"

Alguns podem se perguntar: "Como o FFmpeg identifica qual é o nome do fluxo de saída?"

Simples, caro padawan. Todo argumento de linha de comando do FFmpeg tem uma chave que vai antes do valor - "-i" é a chave para o argumento "nome do fluxo de entrada", "-f" é a chave para o argumento "formato de arquivo", e assim vai. Porém, o fluxo de saída é o único argumento que não tem chave.

Isso é muito importante, pois caso você se esquecer de colocar um valor em uma chave, ou uma chave em um argumento, o FFmpeg vai interpretar aquele "item órfão" como o nome de um fluxo de saída, e provavelmente gerar um erro.

Conclusão

Nós vimos aqui o básico do básico sobre o FFmpeg. Me desculpem se vocês acharem que eu enrolei muito pra uma primeira lição, mas é que o FFmpeg é sim um programa complicado de se usar, requer que você memorize muita coisa e tenha em mente muitas coisas ao construir um comando. Então é importante que os conceitos sejam introduzidos devagar e de forma bem explicada.

Lição 2 - Codecs, Containers e Rate Control

Dúvidas? Perguntas?

Caso você queira me perguntar algo, tirar uma dúvida, fazer um elogio ou uma crítica, pode me contatar pelos canais abaixo:

E-mail: victorcarneiro2009@gmail.com
Telegram: @vitinhocarneiro

Por favor, caso você mande e-mail, peço que você identifique claramente no assunto da mensagem que está falando desse tutorial, para que eu possa identificar seu e-mail mais facilmente e te responder rápido.

Índice

Lição 1 - O Básico do Básico
Lição 2 - Codecs, Containers e Rate Control
Lição 3 - Resolução, Taxa de quadros e Qualidade de Imagem
Lição 4 - em breve!


Por Victor Carneiro - 26/02/2017. Revisado em 01/03/2017. Conteúdo licenciado sob a licença MIT - disponível aqui.