Vi imagens GIF animadas de transmissões de tela (como a abaixo) promovidas algumas vezes neste site como uma maneira de melhorar as respostas.

Que cadeia de ferramentas está sendo usada para criá-las? Existe um programa que faça isso automaticamente, ou as pessoas fazem screencasts, os convertem em uma série de quadros estáticos e criam as imagens GIF?

Olhadinha

É um novo aplicativo que permite gravar facilmente GIFs na tela.

De qualquer forma, lembre-se de que os GIFs têm uma paleta de cores muito limitada, portanto, não é uma boa ideia usá-los.

Desde o Ubuntu 18.10, você pode instalar o Peek diretamente.

sudo apt install peek

Para versões mais antigas do Ubuntu, você pode instalar as versões mais recentes do Peek a partir do seu PPA .

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

Encontre mais informações no repositório do GitHub .

Byzanz

O melhor software que já encontrei para gravar screencasts de GIF é o Byzanz.

O Byzanz é ótimo porque grava diretamente no GIF, a qualidade e o FPS são impressionantes, mantendo o tamanho dos arquivos no mínimo.

Instalação

O Byzanz agora está disponível no repositório do universo:

sudo apt-get install byzanz

Uso

Quando está instalado, você pode executá-lo em um terminal.

Este é um pequeno exemplo que fiz agora com

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

Primeiro instale isto:

sudo apt-get install imagemagick mplayer gtk-recordmydesktop

esses são os materiais necessários, ImageMagick, MPlayer e Desktop Recorder. Em seguida, use o Desktop Recorder para capturar uma parte da tela / aplicativo a ser usada como screencast. Depois que o Desktop Recorder salvou a gravação em um vídeo OGV , o MPlayer será usado para capturar capturas de tela JPEG, salvando-as no diretório 'output'.

Em um terminal:

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

Use o ImageMagick para converter as capturas de tela em gifs animados.

convert output/* output.gif

você pode otimizar as capturas de tela da seguinte maneira:

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

visão global

Esta resposta contém três scripts de shell:

1. byzanz-record-window - Para selecionar uma janela para gravação.
2. byzanz-record-region - Para selecionar uma parte da tela para gravação.
3. Um front-end simples da GUI para 1, do MHC .

Introdução

Obrigado Bruno Pereira por me apresentarbyzanz ! É bastante útil para criar animações GIF. As cores podem estar desativadas em alguns casos, mas o tamanho do arquivo compensa isso. Exemplo: 40 segundos, 3.7Mb .

Uso

Salve um / todos os dois scripts a seguir em uma pasta dentro do seu $PATH. Aqui está um exemplo de como usar o primeiro script para criar um screencast de uma janela específica.

1. Corre byzanz-record-window 30 -c output.gif
2. Vá para a janela (alt-tab) que você deseja capturar. Clique nisso.
3. Aguarde 10 segundos (codificados $DELAY), nos quais você se prepara para gravar.
4. Após o sinal sonoro (definido na beepfunção), byzanzserá iniciado.
5. Após 30 segundos (esse é o significado da 30etapa 1), byzanztermina. Um sinal sonoro será transmitido novamente.

Eu incluí o -csinalizador byzanz-record-windowpara ilustrar que quaisquer argumentos ao meu script shell são anexados a byzanz-recordele mesmo. A -cbandeira diz byzanzpara incluir também o cursor no screencast.
Veja man byzanz-recordou byzanz-record --helppara mais detalhes.

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

Dependência: xrectselde xrectsel . Clone o repositório e execute makepara obter o executável. (Se protestar, não há makefile, execute ./bootstrape ./configureantes de executar o `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

Versão Gui de byzanz-record-window

(comentário do MHC ): tomei a liberdade de modificar o script com um simples diálogo 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

Uma das melhores ferramentas que eu uso é ffmpeg. Ele pode pegar a maioria dos vídeos de uma ferramenta de screencast, como kazamconvertê-los em outro formato.

Instale isso no centro de software - ele será instalado automaticamente se você instalar o excelente ubuntu-restricted-extraspacote.

O Kazam pode produzir nos formatos de vídeo mp4ou webm. Geralmente, você obtém melhores resultados em mp4formato.

exemplo de sintaxe de criação de GIF

A sintaxe básica para converter vídeo em gif é:

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

GIFs convertidos - especialmente aqueles com 25/29 quadros por segundo padrão podem ser muito grandes. Por exemplo - um vídeo de 800Kb webm de 15 segundos e 25fps pode gerar 435Mb!

Você pode reduzir isso por vários métodos:

taxa de quadros

Use a opção -r [frame-per-second]

por exemplo ffmpeg -i Untitled_Screencast.webm -r 1 -pix_fmt rgb24 out.gif

Tamanho reduzido de 435Mb para 19Mb

limite de tamanho de arquivo

Use a opção -fs [filesize]

por exemplo ffmpeg -i Untitled_Screencast.webm -fs 5000k -pix_fmt rgb24 out.gif

Nota - este é um tamanho aproximado do arquivo de saída, portanto o tamanho pode ser um pouco maior que o especificado.

tamanho do vídeo de saída

Use a opção -s [widthxheight]

por exemplo ffmpeg -i Untitled_Screencast.webm -s 320x200 -pix_fmt rgb24 out.gif

Isso reduziu o tamanho do vídeo de 1366x768 de exemplo para 26Mb

loop para sempre

Às vezes, você pode querer que o GIF faça um loop para sempre.

Use a opção -loop_output 0

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

otimizar e encolher ainda mais

se você usar imagemagick convertcom um fator de distorção entre 3% e 10%, poderá reduzir drasticamente o tamanho da imagem

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

finalmente

combine algumas dessas opções para reduzir a algo gerenciável para o Ask Ubuntu.

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

Seguido por

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

exemplo

Silentcast

O Silentcast é outra ótima ferramenta baseada em GUI para criar imagens .gif animadas. Suas características incluem:

• 4 modos de gravação:

  1. Tela inteira

  2. Janela interior

  3. Janela com decoração

  4. Seleção personalizada

• 3 formatos de saída:

  1. .gif

  2. .mp4

  3. .webm

  4. .png (quadros)

  5. .mkv

• Não é necessária instalação (portátil)

• Diretório de trabalho personalizado

• Fps personalizados

Instalação

Se você deseja uma instalação regular e está executando uma versão suportada do Ubuntu, pode instalar o Silentcast by PPA:

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

Se você não está executando uma versão suportada do Ubuntu (você realmente deve atualizar!), Precisará baixar a versão mais recente da página do GitHub e satisfazer manualmente as dependências (você pode adquirir o yad e o ffmpeg daqui e aqui, respectivamente) ou, se você estiver executando uma versão um pouco mais recente, como a 13.10, tente fazer o download do .deb diretamente .

Se você estiver usando o Gnome, poderá instalar a extensão Topicons para facilitar a interrupção do Silentcast.

Uso

Inicie o Silentcast a partir da interface gráfica do seu ambiente de área de trabalho ou execute o silentcastcomando em um terminal. Escolha suas configurações e siga as instruções na tela. Quando terminar de gravar, você verá uma caixa de diálogo para otimizar a saída final removendo um certo número de quadros.

Para diretrizes de uso mais detalhadas, consulte o README, a versão on - line do GitHub ou a versão local armazenada no /usr/share/doc/silentcastzless ou no seu editor favorito.

Notas:

O Silentcast ainda está em fase de desenvolvimento e, embora seja bastante estável, você pode encontrar alguns bugs. Se sim, informe-os no rastreador de problemas do GitHub do projeto . Se você tiver problemas para instalar a partir do PPA e estiver executando uma versão suportada do Ubuntu, deixe um comentário abaixo ou entre em contato com o mantenedor (me) no Launchpad.

Existem todos os tipos de maneiras complicadas e bem-funcionais (presumivelmente) de fazer isso listadas aqui. No entanto, eu nunca quis passar por esse processo antes nem depois. Portanto, eu simplesmente uso um conversor on-line que atenda às minhas necessidades nas poucas vezes em que for necessário. Eu usei este site:

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

Não é o meu site e não sou afiliado a eles de forma alguma. Eles são os únicos nos meus favoritos e existem muitos mais.

Eu criei record-gif.shuma versão melhorada do Rob W'sbyzanz-record-region :

Uma interface gráfica fraca byzanz, melhorou a experiência do usuário ( área selecionável pelo mouse , barra de progresso de gravação, gravação com capacidade de reprodução ).

• definir gravação duration;
• definir save_asdestino;
• selecione - com o mouse - a área a ser gravada;
• crie um script para reproduzir a gravação (cf. $HOME/record.again).

Instalar

Eu também criei um script de instalação

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

1. Instale estes 3 pacotes: imagemagick mplayer gtk-recordmydesktop
2. Execute o Desktop Recorder para capturar uma parte da tela / aplicativo a ser usada como screencast
3. Faça o download ogv2gif.shem https://github.com/nicolas-raoul/ogv2gif
4. Corre: ./ogv2gif.sh yourscreencast.ogv
5. O arquivo GIF será colocado no mesmo diretório

100% inspirado na resposta de maniat1k .

Se você quiser ficar ainda mais sofisticado, use um método mais sofisticado do que os gifs animados usando o screencasting de tela HTMl5. O projeto x11-canvas-screencast criará uma captura de tela animada em tela html5.

Você pode ter visto alguns exemplos famosos dessa tecnologia no site Sublime Text. x11-canvas-screencastleva esse método um passo adiante ao incorporar o rastreamento do cursor do mouse. Aqui está uma demonstração do que o x11-canvas-screencast produz

O resultado é melhor do que um gif animado, pois não se limita ao número de cores que possui e ocupa menos largura de banda.

Ok, então para capturar também os cliques do mouse, a única coisa que encontrei foi key-mon(via README of screenkey):

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

Então eu:

• Começar key-mon
• Use xrectselpara colocar as coordenadas da tela em um byzanzcomando
• Execute o byzanzcomando

... e fica mais ou menos assim:

Observe que key-mon --visible_clickdesenharia um círculo ao redor do ponteiro do mouse ao clicar com o mouse - o que eu preferiria, mas no Ubuntu 14.04.5 LTS isso está um pouco quebrado, pois esse círculo não aparece e desaparece rápido o suficiente para ilustrar corretamente os cliques (ou seja, pressionamentos e liberações do mouse).

Eu criei recentemente uma versão combinada de scripts já postados aqui.
Basicamente, ele permite gravar a região da tela, mas com uma GUI simples.

Obrigado por Rob W por fornecer esses scripts legais

Aqui está o código (ou essência, se você quiser):

#!/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 você também quiser gravações visíveis de cliques do mouse ou pressionamentos de tecla, a screenkey é sua melhor aposta: https://github.com/wavexx/screenkey

Use gtk-recordmydesktope ffmpeg:

apt-get install gtk-recordmydesktop ffmpeg

Execute o RecordMyDesktop capture uma parte da tela / aplicativo para usar como screencast:

gtk-recordmydesktop

Crie ogv2gif.shcom o seguinte conteúdo:

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

Use-o :

./ogv2gif.sh yourscreencast.ogv

Referências :

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

Eu testei todo o método acima, achei o mais simples é:

1. use gtk-recordmydesktop e key-mon para obter um ogv
2. ffmpeg -i xx.ogv xx.gif <- sem nenhum parâmetro .

o fps é original e o tamanho do gif é menor que o arquivo ogv.