Video rotanti con FFmpeg

Ho cercato di capire come ruotare i video con FFmpeg. Sto lavorando con i video di iPhone ripresi in modalità verticale. So come determinare gli attuali gradi di rotazione usando MediaInfo (libreria eccellente, btw) ma ora sono bloccato su FFmpeg.

Da quello che ho letto, quello che devi usare è un'opzione vfilter . Secondo quello che vedo, dovrebbe apparire così:

ffmpeg -vfilters "rotate=90" -i input.mp4 output.mp4

Tuttavia, non riesco a farlo funzionare. Innanzitutto, -vfilters non esiste più, ora è solo -vf . Secondo, ottengo questo errore:

No such filter: 'rotate'
Error opening filters!

Per quanto ne so, ho una build all-options-on di FFmpeg. L'esecuzione di ffmpeg -filters mostra questo:

Filters:
anull            Pass the source unchanged to the output.
aspect           Set the frame aspect ratio.
crop             Crop the input video to x:y:width:height.
fifo             Buffer input images and send them when they are requested.
format           Convert the input video to one of the specified pixel formats.
hflip            Horizontally flip the input video.
noformat         Force libavfilter not to use any of the specified pixel formats
 for the input to the next filter.
null             Pass the source unchanged to the output.
pad              Pad input image to width:height[:x:y[:color]] (default x and y:
 0, default color: black).
pixdesctest      Test pixel format definitions.
pixelaspect      Set the pixel aspect ratio.
scale            Scale the input video to width:height size and/or convert the i
mage format.
slicify          Pass the images of input video on to next video filter as multi
ple slices.
unsharp          Sharpen or blur the input video.
vflip            Flip the input video vertically.
buffer           Buffer video frames, and make them accessible to the filterchai
n.
color            Provide an uniformly colored input, syntax is: [color[:size[:ra
te]]]
nullsrc          Null video source, never return images.
nullsink         Do absolutely nothing with the input video.

Avere le opzioni per vflip e hflip è fantastico e tutto, ma non mi porterà dove devo andare. Ho bisogno della possibilità di ruotare i video di almeno 90 gradi. 270 gradi sarebbe anche un'opzione eccellente da avere. Dove sono finite le opzioni di rotazione?

Ruota di 90 in senso orario:

ffmpeg -i in.mov -vf "transpose=1" out.mov

Per il parametro transpose è possibile passare:

0 = 90CounterCLockwise and Vertical Flip (default)
1 = 90Clockwise
2 = 90CounterClockwise
3 = 90Clockwise and Vertical Flip

Utilizzare -vf "transpose=2,transpose=2"per 180 gradi.

Assicurati di utilizzare una versione recente di ffmpeg da qui (una build statica funzionerà correttamente ).

Si noti che ciò ricodificherà le parti audio e video. Di solito è possibile copiare l'audio senza toccarlo, utilizzando -c:a copy. Per modificare la qualità del video, imposta la velocità in bit (ad esempio con -b:v 1M) o dai un'occhiata alla guida alla codifica H.264 se desideri opzioni VBR.

Una soluzione è anche quella di utilizzare questo comodo script .

Se non vuoi ricodificare il tuo video E il tuo lettore è in grado di gestire i metadati di rotazione, puoi semplicemente cambiare la rotazione nei metadati usando ffmpeg:

ffmpeg -i input.m4v -metadata:s:v rotate="90" -codec copy output.m4v

Hai già provato transpose? Mi piace (dall'altra risposta)

 ffmpeg -i input -vf transpose=2 output

Se si utilizza una versione precedente, è necessario aggiornare ffmpeg se si desidera utilizzare la funzione di trasposizione, poiché è stata aggiunta nell'ottobre 2011.

La pagina di download di FFmpeg offre build statiche che puoi eseguire direttamente senza doverle compilare.

Mi sono imbattuto in questa pagina mentre cercavo la stessa risposta. Sono passati ormai sei mesi da quando è stato richiesto inizialmente e le build sono state aggiornate molte volte da allora. Tuttavia, volevo aggiungere una risposta a chiunque si imbattesse qui alla ricerca di queste informazioni.

Sto usando la versione di Debian Squeeze e FFmpeg da quei repository.

La pagina MAN per ffmpeg indica il seguente uso

ffmpeg -i inputfile.mpg -vf "transpose=1" outputfile.mpg

La chiave è che non devi usare una variabile di grado, ma una variabile di impostazione predefinita dalla pagina MAN.

0=90CounterCLockwise and Vertical Flip  (default) 
1=90Clockwise 
2=90CounterClockwise 
3=90Clockwise and Vertical Flip

Per ruotare l'immagine in senso orario è possibile utilizzare il filtro di rotazione, che indica un angolo positivo in radianti. Con 90 gradi equivalenti a PI / 2, puoi farlo in questo modo:

ffmpeg -i in.mp4 -vf "rotate=PI/2" out.mp4

per il senso antiorario l'angolo deve essere negativo

ffmpeg -i in.mp4 -vf "rotate=-PI/2" out.mp4

Il filtro di trasposizione funzionerà ugualmente bene per 90 gradi, ma per altri angoli questa è una scelta più veloce o unica.

ffmpeg -vfilters "rotate=90" -i input.mp4 output.mp4 

non funzionerà, anche con l'ultima fonte ...

deve cambiare l'ordine:

ffmpeg -i input.mp4 -vf vflip output.mp4

funziona bene

Se ricevi un errore "Il codec è sperimentale ma i codec sperimentali non sono abilitati" usa questo:

ffmpeg -i inputFile -vf "transpose=1" -c:a copy outputFile

È successo con me per alcuni file .mov con audio aac.

Questo script che genererà i file con la struttura di directory in "fixedFiles". Al momento è fisso su file MOV ed eseguirà una serie di trasformazioni a seconda della "rotazione" originale del video. Funziona con i video acquisiti iOS su un Mac con Mavericks, ma dovrebbe essere facilmente esportabile. Si affida ad aver installato sia exiftool che ffmpeg .

#!/bin/bash

# rotation of 90 degrees. Will have to concatenate.
#ffmpeg -i <originalfile> -metadata:s:v:0 rotate=0 -vf "transpose=1" <destinationfile>
#/VLC -I dummy -vvv <originalfile> --sout='#transcode{width=1280,vcodec=mp4v,vb=16384,vfilter={canvas{width=1280,height=1280}:rotate{angle=-90}}}:std{access=file,mux=mp4,dst=<outputfile>}\' vlc://quit

#Allowing blanks in file names
SAVEIFS=$IFS
IFS=$(echo -en "\n\b")

#Bit Rate
BR=16384

#where to store fixed files
FIXED_FILES_DIR="fixedFiles"
#rm -rf $FIXED_FILES_DIR
mkdir $FIXED_FILES_DIR

# VLC
VLC_START="/Applications/VLC.app/Contents/MacOS/VLC -I dummy -vvv"
VLC_END="vlc://quit"


#############################################
# Processing of MOV in the wrong orientation
for f in `find . -regex '\./.*\.MOV'` 
do
  ROTATION=`exiftool "$f" |grep Rotation|cut -c 35-38`
  SHORT_DIMENSION=`exiftool "$f" |grep "Image Size"|cut -c 39-43|sed 's/x//'`
  BITRATE_INT=`exiftool "$f" |grep "Avg Bitrate"|cut -c 35-38|sed 's/\..*//'`
  echo Short dimension [$SHORT_DIMENSION] $BITRATE_INT

  if test "$ROTATION" != ""; then
    DEST=$(dirname ${f})
    echo "Processing $f with rotation $ROTATION in directory $DEST"
    mkdir -p $FIXED_FILES_DIR/"$DEST"

    if test "$ROTATION" == "0"; then
      cp "$f" "$FIXED_FILES_DIR/$f"

    elif test "$ROTATION" == "180"; then
#      $(eval $VLC_START \"$f\" "--sout="\'"#transcode{vfilter={rotate{angle=-"$ROTATION"}},vcodec=mp4v,vb=$BR}:std{access=file,mux=mp4,dst=\""$FIXED_FILES_DIR/$f"\"}'" $VLC_END )
      $(eval ffmpeg -i \"$f\" -vf hflip,vflip -r 30 -metadata:s:v:0 rotate=0 -b:v "$BITRATE_INT"M -vcodec libx264 -acodec copy \"$FIXED_FILES_DIR/$f\")

    elif test "$ROTATION" == "270"; then
      $(eval ffmpeg -i \"$f\" -vf "scale=$SHORT_DIMENSION:-1,transpose=2,pad=$SHORT_DIMENSION:$SHORT_DIMENSION:\(ow-iw\)/2:0" -r 30 -s "$SHORT_DIMENSION"x"$SHORT_DIMENSION" -metadata:s:v:0 rotate=0 -b:v "$BITRATE_INT"M -vcodec libx264 -acodec copy \"$FIXED_FILES_DIR/$f\" )

    else
#      $(eval $VLC_START \"$f\" "--sout="\'"#transcode{scale=1,width=$SHORT_DIMENSION,vcodec=mp4v,vb=$BR,vfilter={canvas{width=$SHORT_DIMENSION,height=$SHORT_DIMENSION}:rotate{angle=-"$ROTATION"}}}:std{access=file,mux=mp4,dst=\""$FIXED_FILES_DIR/$f"\"}'" $VLC_END )
      echo ffmpeg -i \"$f\" -vf "scale=$SHORT_DIMENSION:-1,transpose=1,pad=$SHORT_DIMENSION:$SHORT_DIMENSION:\(ow-iw\)/2:0" -r 30 -s "$SHORT_DIMENSION"x"$SHORT_DIMENSION" -metadata:s:v:0 rotate=0 -b:v "$BITRATE_INT"M -vcodec libx264 -acodec copy \"$FIXED_FILES_DIR/$f\" 
      $(eval ffmpeg -i \"$f\" -vf "scale=$SHORT_DIMENSION:-1,transpose=1,pad=$SHORT_DIMENSION:$SHORT_DIMENSION:\(ow-iw\)/2:0" -r 30 -s "$SHORT_DIMENSION"x"$SHORT_DIMENSION" -metadata:s:v:0 rotate=0 -b:v "$BITRATE_INT"M -vcodec libx264 -acodec copy \"$FIXED_FILES_DIR/$f\" )

    fi

  fi

echo 
echo ==================================================================
sleep 1
done

#############################################
# Processing of AVI files for my Panasonic TV
# Use ffmpegX + QuickBatch. Bitrate at 16384. Camera res 640x424
for f in `find . -regex '\./.*\.AVI'` 
do
  DEST=$(dirname ${f})
  DEST_FILE=`echo "$f" | sed 's/.AVI/.MOV/'`
  mkdir -p $FIXED_FILES_DIR/"$DEST"
  echo "Processing $f in directory $DEST"
  $(eval ffmpeg -i \"$f\" -r 20 -acodec libvo_aacenc -b:a 128k -vcodec mpeg4 -b:v 8M -flags +aic+mv4 \"$FIXED_FILES_DIR/$DEST_FILE\" )
echo 
echo ==================================================================

done

IFS=$SAVEIFS

La risposta di Alexy ha funzionato quasi per me, tranne che stavo ottenendo questo errore:

base dei tempi 1/90000 non supportata dallo standard MPEG 4, il valore massimo ammesso per il denominatore della base dei tempi è 65535

Ho dovuto solo aggiungere un parametro (-r 65535/2733) al comando e ha funzionato. Il comando completo era quindi:

ffmpeg -i in.mp4 -vf "transpose=1" -r 65535/2733 out.mp4

Un'ulteriore soluzione con un approccio diverso rispetto alle ultime soluzioni menzionate è quella di verificare se il driver della fotocamera supporta i controlli della fotocamera v4l2 (che è molto comune).
Nel terminale basta digitare:

v4l2-ctl -L

Se il driver della fotocamera supporta i controlli della fotocamera v4l2, dovresti ottenere qualcosa del genere (l'elenco che segue dipende dai controlli supportati dal driver della fotocamera):

               contrast (int)    : min=0 max=255 step=1 default=0 value=0 flags=slider
             saturation (int)    : min=0 max=255 step=1 default=64 value=64 flags=slider
                    hue (int)    : min=0 max=359 step=1 default=0 value=0 flags=slider
white_balance_automatic (bool)   : default=1 value=1 flags=update
            red_balance (int)    : min=0 max=4095 step=1 default=0 value=128 flags=inactive, slider
           blue_balance (int)    : min=0 max=4095 step=1 default=0 value=128 flags=inactive, slider
               exposure (int)    : min=0 max=65535 step=1 default=0 value=885 flags=inactive, volatile
         gain_automatic (bool)   : default=1 value=1 flags=update
                   gain (int)    : min=0 max=1023 step=1 default=0 value=32 flags=inactive, volatile
        horizontal_flip (bool)   : default=0 value=0
          vertical_flip (bool)   : default=0 value=0

E se sei fortunato, supporta horizontal_flip e vertical_flip .
Quindi tutto ciò che devi fare è impostare il parametro orizzontale :

v4l2-ctl --set-ctrl horizontal_flip=1

oppure vertical_flip di:

v4l2-ctl --set-ctrl vertical_flip=1

quindi puoi chiamare il tuo dispositivo video per acquisire un nuovo video (vedi esempio sotto) e il video verrà ruotato / capovolto.

ffmpeg -f v4l2 -video_size 640x480 -i /dev/video0 -vcodec libx264 -f mpegts input.mp4

Naturalmente, se è necessario elaborare un video già esistente, questo metodo non è la soluzione che stai cercando.

Il vantaggio di questo approccio è che capovolgiamo l'immagine a livello del sensore, quindi il sensore del driver ci fornisce già l'immagine capovolta e ciò salva l'applicazione (come FFmpeg) ogni ulteriore e inutile elaborazione.

Sfortunatamente, la versione Ubuntu di ffmpeg supporta i videofiltri.

È necessario utilizzare avidemux o qualche altro editor per ottenere lo stesso effetto.

In modo programmatico, è stato raccomandato mencoder.

Smartphone: ha registrato un video in formato verticale

Vuoi inviarlo a un sito web era 90 ° a sinistra (antiorario, formato orizzontale) hmm.

ffmpeg -i input.mp4 -vf "rotate=0" output.mp4

lo fa. Ho di nuovo il formato verticale

debian buster: ffmpeg --version ffmpeg versione 4.1.4-1 ~ deb10u1 Copyright (c) 2000-2019 gli sviluppatori di FFmpeg