Ho visto immagini GIF animate di schermate (come quella qui sotto) promosse alcune volte su questo sito come un modo per migliorare le risposte.

Quale toolchain viene utilizzato per crearli? Esiste un programma che lo fa automagicamente o le persone eseguono screencast, li convertono in una serie di frame statici e quindi creano le immagini GIF?

Sbirciare

È una nuova applicazione che ti consente di registrare facilmente GIF dal tuo schermo.

Ad ogni modo, tieni presente che le GIF hanno una tavolozza di colori molto limitata, quindi non è una buona idea usarle.

Da Ubuntu 18.10 è possibile installare direttamente Peek.

sudo apt install peek

Per le versioni precedenti di Ubuntu, è possibile installare le ultime versioni di Peek dal suo PPA .

sudo add-apt-repository ppa:peek-developers/stable
sudo apt update
sudo apt install peek

Ulteriori informazioni nel repository GitHub .

Byzanz

Il miglior software che abbia mai trovato per registrare screencast GIF è Byzanz.

Byzanz è fantastico perché registra direttamente su GIF, la qualità e FPS sono impressionanti mantenendo al minimo le dimensioni dei file.

Installazione

Byzanz è ora disponibile dal repository universe:

sudo apt-get install byzanz

uso

Quando è installato è possibile eseguirlo in un terminale.

Questo è un piccolo esempio con cui ho fatto proprio ora

byzanz-record --duration=15 --x=200 --y=300 --width=700 --height=400 out.gif

Prima installa questo:

sudo apt-get install imagemagick mplayer gtk-recordmydesktop

queste sono le cose richieste, ImageMagick, MPlayer e Desktop Recorder. Quindi utilizzare Desktop Recorder per acquisire una parte dello schermo / dell'applicazione da utilizzare come screencast. Dopo che Desktop Recorder ha salvato la registrazione in un video OGV , MPlayer verrà utilizzato per acquisire schermate JPEG, salvandole nella directory "output".

Su un terminale:

mplayer -ao null <video file name> -vo jpeg:outdir=output

Usa ImageMagick per convertire le schermate in gif animate.

convert output/* output.gif

puoi ottimizzare gli screenshot in questo modo:

convert output.gif -fuzz 10% -layers Optimize optimised.gif

Panoramica

Questa risposta contiene tre script di shell:

1. byzanz-record-window - Per selezionare una finestra per la registrazione.
2. byzanz-record-region - Per selezionare una parte dello schermo per la registrazione.
3. Un semplice front-end GUI per 1, di MHC .

introduzione

Grazie Bruno Pereira per avermi fatto conoscerebyzanz ! È abbastanza utile per creare animazioni GIF. In alcuni casi i colori potrebbero essere spenti, ma le dimensioni del file compensano. Esempio: 40 secondi, 3,7 Mb .

uso

Salvare uno / tutti i seguenti due script in una cartella all'interno di $PATH. Ecco un esempio sull'uso del primo script per creare uno screencast di una finestra specifica.

1. Correre byzanz-record-window 30 -c output.gif
2. Vai alla finestra (alt-tab) che vuoi catturare. Cliccaci sopra.
3. Attendere 10 secondi (hard-coded in $DELAY), in cui ci si prepara per la registrazione.
4. Dopo il segnale acustico (definito nella beepfunzione), byzanzverrà avviato.
5. Dopo 30 secondi (questo è il significato del 30passaggio 1), byzanztermina. Un segnale acustico verrà nuovamente trasmesso.

Ho incluso la -cbandiera byzanz-record-windowper illustrare che qualsiasi argomento al mio script di shell viene aggiunto a byzanz-recordse stesso. La -cbandiera dice byzanzdi includere anche il cursore nello screencast.
Vedi man byzanz-recordo byzanz-record --helpper maggiori dettagli.

byzanz-record-window

#!/bin/bash

# Delay before starting
DELAY=10

# Sound notification to let one know when recording is about to start (and ends)
beep() {
    paplay /usr/share/sounds/KDE-Im-Irc-Event.ogg &
}

# Duration and output file
if [ $# -gt 0 ]; then
    D="--duration=$@"
else
    echo Default recording duration 10s to /tmp/recorded.gif
    D="--duration=10 /tmp/recorded.gif"
fi
XWININFO=$(xwininfo)
read X <<< $(awk -F: '/Absolute upper-left X/{print $2}' <<< "$XWININFO")
read Y <<< $(awk -F: '/Absolute upper-left Y/{print $2}' <<< "$XWININFO")
read W <<< $(awk -F: '/Width/{print $2}' <<< "$XWININFO")
read H <<< $(awk -F: '/Height/{print $2}' <<< "$XWININFO")

echo Delaying $DELAY seconds. After that, byzanz will start
for (( i=$DELAY; i>0; --i )) ; do
    echo $i
    sleep 1
done

beep
byzanz-record --verbose --delay=0 --x=$X --y=$Y --width=$W --height=$H $D
beep

byzanz-record-region

Dipendenza: xrectselda xrectsel . Clonare il repository ed eseguire makeper ottenere l'eseguibile. (Se protesta non c'è makefile, run ./bootstrape ./configureprima di eseguire `make).

#!/bin/bash

# Delay before starting
DELAY=10

# Sound notification to let one know when recording is about to start (and ends)
beep() {
    paplay /usr/share/sounds/KDE-Im-Irc-Event.ogg &
}

# Duration and output file
if [ $# -gt 0 ]; then
    D="--duration=$@"
else
    echo Default recording duration 10s to /tmp/recorded.gif
    D="--duration=10 /tmp/recorded.gif"
fi

# xrectsel from https://github.com/lolilolicon/xrectsel
ARGUMENTS=$(xrectsel "--x=%x --y=%y --width=%w --height=%h") || exit -1

echo Delaying $DELAY seconds. After that, byzanz will start
for (( i=$DELAY; i>0; --i )) ; do
    echo $i
    sleep 1
done
beep
byzanz-record --verbose --delay=0 ${ARGUMENTS} $D
beep

Versione Gui di byzanz-record-window

(commento di MHC ): Mi sono preso la libertà di modificare lo script con un semplice dialogo con la GUI

#!/bin/bash

# AUTHOR:   (c) Rob W 2012, modified by MHC (https://askubuntu.com/users/81372/mhc)
# NAME:     GIFRecord 0.1
# DESCRIPTION:  A script to record GIF screencasts.
# LICENSE:  GNU GPL v3 (http://www.gnu.org/licenses/gpl.html)
# DEPENDENCIES:   byzanz,gdialog,notify-send (install via sudo add-apt-repository ppa:fossfreedom/byzanz; sudo apt-get update && sudo apt-get install byzanz gdialog notify-osd)

# Time and date
TIME=$(date +"%Y-%m-%d_%H%M%S")

# Delay before starting
DELAY=10

# Standard screencast folder
FOLDER="$HOME/Pictures"

# Default recording duration
DEFDUR=10

# Sound notification to let one know when recording is about to start (and ends)
beep() {
    paplay /usr/share/sounds/freedesktop/stereo/message-new-instant.oga &
}

# Custom recording duration as set by user
USERDUR=$(gdialog --title "Duration?" --inputbox "Please enter the screencast duration in seconds" 200 100 2>&1)

# Duration and output file
if [ $USERDUR -gt 0 ]; then
    D=$USERDUR
else
    D=$DEFDUR
fi

# Window geometry
XWININFO=$(xwininfo)
read X < <(awk -F: '/Absolute upper-left X/{print $2}' <<< "$XWININFO")
read Y < <(awk -F: '/Absolute upper-left Y/{print $2}' <<< "$XWININFO")
read W < <(awk -F: '/Width/{print $2}' <<< "$XWININFO")
read H < <(awk -F: '/Height/{print $2}' <<< "$XWININFO")

# Notify the user of recording time and delay
notify-send "GIFRecorder" "Recording duration set to $D seconds. Recording will start in $DELAY seconds."

#Actual recording
sleep $DELAY
beep
byzanz-record -c --verbose --delay=0 --duration=$D --x=$X --y=$Y --width=$W --height=$H "$FOLDER/GIFrecord_$TIME.gif"
beep

# Notify the user of end of recording.
notify-send "GIFRecorder" "Screencast saved to $FOLDER/GIFrecord_$TIME.gif"

ffmpeg

Uno dei migliori strumenti che uso è ffmpeg. Può prendere la maggior parte dei video da uno strumento screencast come kazame convertirlo in un altro formato.

Installa questo dal centro software : viene installato automaticamente se installi il ubuntu-restricted-extraspacchetto eccellente .

Kazam può produrre nei formati video mp4o webm. Generalmente si ottengono risultati migliori in mp4formato.

esempio GIF sintassi

La sintassi di base per convertire i video in GIF è:

ffmpeg -i [inputvideo_filename] -pix_fmt rgb24 [output.gif]

Le GIF convertite, specialmente quelle con un frame standard al 25/29 al secondo, possono essere molto grandi. Ad esempio: un video di 15 secondi con webm da 800 Kb a 25 fps può generare fino a 435 Mb!

Puoi ridurlo con una serie di metodi:

frequenza dei fotogrammi

Usa l'opzione -r [frame-per-second]

per esempio ffmpeg -i Untitled_Screencast.webm -r 1 -pix_fmt rgb24 out.gif

Dimensioni ridotte da 435 Mb a 19 Mb

limite di dimensione del file

Usa l'opzione -fs [filesize]

per esempio ffmpeg -i Untitled_Screencast.webm -fs 5000k -pix_fmt rgb24 out.gif

Nota: questa è una dimensione approssimativa del file di output, quindi la dimensione può essere leggermente più grande di quanto specificato.

dimensione del video in uscita

Usa l'opzione -s [widthxheight]

per esempio ffmpeg -i Untitled_Screencast.webm -s 320x200 -pix_fmt rgb24 out.gif

Ciò ha ridotto le dimensioni del video di esempio 1366x768 fino a 26 Mb

loop per sempre

A volte potresti volere che la GIF sia ripetuta per sempre.

Usa l'opzione -loop_output 0

ffmpeg -i Untitled_Screencast.webm -loop_output 0 -pix_fmt rgb24 out.gif

ottimizzare ulteriormente e ridurre

se si utilizza imagemagick convertcon un fattore di sfocatura tra il 3% e il 10%, è possibile ridurre drasticamente le dimensioni dell'immagine

convert output.gif -fuzz 3% -layers Optimize finalgif.gif

finalmente

combinare alcune di queste opzioni per ridurre a qualcosa gestibile per Ask Ubuntu.

ffmpeg -i Untitled_Screencast.webm -loop_output 0 -r 5 -s 320x200 -pix_fmt rgb24 out.gif

seguito da

convert output.gif -fuzz 8% -layers Optimize finalgif.gif

esempio

Silentcast

Silentcast è un altro ottimo strumento basato su gui per la creazione di immagini GIF animate. Le sue caratteristiche includono:

• 4 modalità di registrazione:

  1. Schermo intero

  2. Finestra interna

  3. Finestra con decorazione

  4. Selezione personalizzata

• 3 formati di output:

  1. .gif

  2. .mp4

  3. .webm

  4. .png (fotogrammi)

  5. .mkv

• Nessuna installazione necessaria (portatile)

• Directory di lavoro personalizzata

• Fps personalizzati

Installazione

Se si desidera un'installazione regolare e si esegue una versione supportata di Ubuntu, è possibile installare Silentcast tramite PPA:

sudo add-apt-repository ppa:sethj/silentcast  
sudo apt-get update  
sudo apt-get install silentcast  

Se non stai eseguendo una versione supportata di Ubuntu (dovresti davvero aggiornare!) Dovrai scaricare l'ultima versione dalla pagina GitHub e soddisfare manualmente le dipendenze (puoi procurarti yad e ffmpeg da qui e qui rispettivamente) o, se stai eseguendo una versione leggermente più recente come 13.10 potresti provare a scaricare direttamente il .deb .

Se stai usando Gnome potresti voler installare l' estensione Topicons per rendere più facile l'arresto di Silentcast.

uso

Avvia Silentcast dalla GUI del tuo ambiente desktop o esegui il silentcastcomando in un terminale. Scegli le tue impostazioni e segui le istruzioni sullo schermo. Al termine della registrazione, verrà visualizzata una finestra di dialogo per l'ottimizzazione dell'output finale rimuovendo un determinato numero di fotogrammi.

Per linee guida di utilizzo più approfondite, dai un'occhiata a README, la versione online di GitHub o la versione locale memorizzata /usr/share/doc/silentcastcon zless o con il tuo editor preferito.

Appunti:

Silentcast è ancora in fase di sviluppo e sebbene sia abbastanza stabile, potresti riscontrare alcuni bug. Se lo fai, ti preghiamo di segnalarli sul tracker dei problemi GitHub del progetto . Se hai problemi con l'installazione da PPA e stai eseguendo una versione supportata di Ubuntu lascia un commento qui sotto o contatta il manutentore (me) su Launchpad.

Ci sono molti modi complicati e ben funzionanti (presumibilmente) per farlo elencati qui. Tuttavia, non ho mai voluto passare attraverso questo processo prima né da allora. Quindi, uso semplicemente un convertitore online che soddisfa le mie esigenze le poche volte che devo farlo. Ho usato questo sito:

http://ezgif.com/video-to-gif

Non è il mio sito e non sono affiliato con loro in alcun modo. Sono solo quelli nei miei segnalibri e ce ne sono molti altri.

Ho creato record-gif.shuna versione migliorata di Rob Wbyzanz-record-region :

Una GUI scadente per byzanz, migliorata l'esperienza dell'utente ( area selezionabile dal mouse , barra di avanzamento della registrazione, registrazione in grado di riprodurre ).

• impostare la registrazione duration;
• impostare la save_asdestinazione;
• selezionare - con il mouse - l'area da registrare;
• creare uno script per ripetere la registrazione (cfr $HOME/record.again.).

Installare

Ho anche creato uno script di installazione

curl --location https://git.io/record-gif.sh | bash -

1. Installa questi 3 pacchetti: imagemagick mplayer gtk-recordmydesktop
2. Esegui Desktop Recorder per acquisire una parte dello schermo / dell'applicazione da utilizzare come screencast
3. Scarica ogv2gif.shda https://github.com/nicolas-raoul/ogv2gif
4. Correre: ./ogv2gif.sh yourscreencast.ogv
5. Il file GIF verrà inserito nella stessa directory

100% ispirato dalla risposta di maniat1k .

Se vuoi diventare ancora più fantasioso, puoi usare un metodo più sofisticato delle gif animate usando lo screencasting su tela HTMl5. Il progetto x11-canvas-screencast creerà un'acquisizione di schermate animate su tela html5.

Potresti aver visto alcuni esempi famosi di questa tecnologia sul sito Web di Sublime Text. x11-canvas-screencastporta questo metodo un ulteriore passo avanti incorporando il tracciamento del cursore del mouse. Ecco una demo di ciò che produce x11-canvas-screencast

Il risultato è migliore di una gif animata poiché non è limitato al numero di colori che ha e richiede meno larghezza di banda.

Ok, quindi per catturare anche i clic del mouse, l'unica cosa che ho trovato è stata key-mon(tramite il README di screenkey):

• https://code.google.com/archive/p/key-mon https://github.com/critiqjo/key-mon
• sudo apt-get install key-mon

Quindi io:

• Inizio key-mon
• Utilizzare xrectselper inserire le coordinate dello schermo in un byzanzcomando
• Esegui il byzanzcomando

... e sembra un po 'così:

Si noti che key-mon --visible_clicktrarrebbe un cerchio attorno al puntatore del mouse al clic del mouse, cosa che preferirei, ma in Ubuntu 14.04.5 LTS questo è in qualche modo rotto, poiché questo cerchio non appare e scompare abbastanza velocemente per illustrare correttamente i clic (es. il mouse preme e rilascia).

Di recente ho creato una versione combinata di script già pubblicati qui.
Fondamentalmente, ti consente di registrare l'area dello schermo, ma con una semplice GUI.

Grazie per Rob W per aver fornito quegli script fantastici

Ecco il codice (o gist se ti piace):

#!/bin/bash

#Records selected screen region, with GUI

#This is combined version of GIF recording scripts, that can be found here: https://askubuntu.com/questions/107726/how-to-create-animated-gif-images-of-a-screencast
#Thanks to Rob W, and the other author (unmentioned), for creating this lovely scripts

#I do not own any rights to code I didn't write
#                                     ~Jacajack

DELAY=5 #Delay before starting
DEFDUR=10 #Default recording duration
TIME=$(date +"%Y-%m-%d_%H%M%S") #Timestamp
FOLDER="$HOME/Pictures/Byzanz" #Default output directory

#Sound notification to let one know when recording is about to start (and ends)
beep() {
    paplay /usr/share/sounds/freedesktop/stereo/message-new-instant.oga &
}

#Custom recording duration as set by user
USERDUR=$(gdialog --title "Duration?" --inputbox "Please enter the screencast duration in seconds" 200 100 2>&1)

#Duration and output file
if [ $USERDUR -gt 0 ]; then
    D=$USERDUR
else
    D=$DEFDUR
fi

#Get coordinates using xrectsel from https://github.com/lolilolicon/xrectsel
REGION=$(xrectsel "--x=%x --y=%y --width=%w --height=%h") || exit -1

notify-send "GIFRecorder" "Recording duration set to $D seconds. Recording will start in $DELAY seconds."

for (( i=$DELAY; i>0; --i )) ; do
    sleep 1
done

#Record
beep
byzanz-record --cursor --verbose --delay=0 ${REGION} --duration=$D "$FOLDER/byzanz-record-region-$TIME.gif"
beep

notify-send "GIFRecorder" "Screencast saved to $FOLDER/byzanz-record-region-$TIME.gif"

Se desideri anche registrazioni visibili dei clic del mouse o dei tasti, allora screenkey è la soluzione migliore: https://github.com/wavexx/screenkey

Usa gtk-recordmydesktope ffmpeg:

apt-get install gtk-recordmydesktop ffmpeg

Esegui RecordMyDesktop acquisisci una parte dello schermo / dell'applicazione da utilizzare come screencast:

gtk-recordmydesktop

Crea ogv2gif.shcon il seguente contenuto:

INPUT_FILE=$1
FPS=15
WIDTH=320
TEMP_FILE_PATH="~/tmp.png"
ffmpeg -i $INPUT_FILE -vf fps=$FPS,scale=$WIDTH:-1:flags=lanczos,palettegen $TEMP_FILE_PATH
ffmpeg -i $INPUT_FILE -i $TEMP_FILE_PATH -loop 0 -filter_complex "fps=$FPS,scale=$WIDTH:-1:flags=lanczos[x];[x][1:v]paletteuse" $INPUT_FILE.gif
rm $TEMP_FILE_PATH

Usalo:

./ogv2gif.sh yourscreencast.ogv

Riferimenti :

• https://gist.github.com/fedir/56aeddde59571402a0d94f78eb6c7a5c
• https://unix.stackexchange.com/questions/35282/convert-ogv-video-to-gif-animation

Ho testato tutto il metodo sopra, ho scoperto che il più semplice è:

1. usa gtk-recordmydesktop e key-mon per ottenere un ogv
2. ffmpeg -i xx.ogv xx.gif <- senza alcun parametro .

il file fps è originale e la dimensione gif è inferiore al file ogv.