Screen capture (Português) - ArchWiki

Jump to content

# Screen capture (Português)

From ArchWiki

Related articles

- Key binding

This article lists and describes screenshot and screencast software.

## Aplicativos de captura de tela

### Aplicativos de captura

- CoreShot — Simples e leve aplicativo de captura de tela para X11. Parte da C-Suite.

  https://cubocore.gitlab.io/ || coreshotAUR

- Deepin Screenshot — Ferramenta de captura de tela bastante fácil de usar, agora obsoleto e fundido no Deepin Screen Recorder. Um problema conhecido com a funcionalidade do clipboard é corrigido por deepin-screenshot-copy-patchAUR[link quebrado: package not found].

  https://www.deepin.org/en/original/deepin-screenshot/ || deepin-screenshot[link quebrado: package not found]

- Escrotum — Captura de tela usando python e gtk3, inspirado no scrot.

  https://github.com/Roger/escrotum || escrotum-gitAUR

- Flameshot — Software baseado em Qt5 para captura interativa de imagens de tela. Seleccione a área desejada, desenhe com diferentes ferramentas e desfrute das capacidades de personalização.

  https://github.com/lupoDharkael/flameshot || flameshot

- GNOME Screenshot — Aplicativo de captura de tela para o GNOME.

  https://gitlab.gnome.org/GNOME/gnome-screenshot/ || gnome-screenshot

- grim — Captura de tela para compositores Wayland.

  https://sr.ht/~emersion/grim/ || grim

- gscreenshot — Utilitário simples de captura de tela GTK com delay, seleção e funcionalidade "copiar para a área de transferência".

  https://github.com/thenaterhood/gscreenshot || gscreenshotAUR

- HotShots — Aplicação para capturar tela e guardá-los numa variedade de formatos de imagem, bem como adicionar anotações e dados gráficos (setas, linhas, textos, ...).

  https://github.com/obiwankennedy/HotShots || hotshots-gitAUR

- imgur-screenshot — Faz uma captura de tela e faz upload para o imgur + extras.

  https://github.com/jomo/imgur-screenshot || imgur-screenshotAUR

- ksnip — Ksnip é uma ferramenta de captura de tela multiplataforma baseada em Qt que fornece muitas características de anotação para as suas capturas de tela.

  https://github.com/ksnip/ksnip || ksnip

- Lightscreen — Ferramenta simples para automatizar o tedioso processo de guardar e catalogar capturas de tela, funciona como um processo de fundo oculto que é iniciado com uma (ou várias) teclas de atalho e depois guarda um cópia de captura de tela no disco de acordo com as preferências do utilizador.

  https://lightscreen.com.ar || lightscreenAUR

- LXQt Screenshot — Aplicativo de captura de tela para LXQt. Use com `lximage-qt --screenshot`.

  https://github.com/lxde/lximage-qt || lximage-qt

- maim — Utilitário simples de linha de comando que tira capturas de tela. Destina-se a substituir o scrot e funciona melhor do que o scrot em muitos aspectos.

  https://github.com/naelstrof/maim || maim

- MATE Screenshot — Aplicativo de captura de tela para MATE desktop.

  https://mate-desktop.org || mate-utils

- menyoki — Captura de {tela,gravação} e executar ImageOps na linha de comando.

  https://github.com/orhun/menyoki || menyoki

- mss — Um módulo Python xrandr-consciente com um CLI mínimo.

  https://pypi.org/project/mss/ || python-mss

- Pantheon Screenshot — Aplicativo de captura de tela para elementary OS.

  https://github.com/elementary/screenshot || pantheon-screenshot

- ScreenCloud — Captura uma imagem da tela inteira ou selecionar uma área e depois carregar a imagem para imgur+auth. tem plugins e bandeja do sistema.

  https://screencloud.net/ || screencloudAUR

- ScreenGrab — Aplicação multiplataforma concebida para tirar rapidamente fotografias de ecrã (Qt).

  https://github.com/DOOMer/screengrab || screengrab

- Scrot — Aplicativos simples de captura de tela para X.

  https://github.com/resurrecting-open-source-projects/scrot || scrot

- Shotgun — Aplicativo minimalista de captura de tela escrito em Rust. Segundo o autor, é duas vezes mais rápido que a maim..

  https://github.com/neXromancers/shotgun || shotgun

- Shutter — Aplicativo de captura de tela rico em funcionalidades e programa de edição. Suporte delay.

  https://shutter-project.org/ || shutter

- Spectacle — KDE aplicação para capturar tela inteira. É capaz de capturar imagens de toda a área de trabalho, uma única janela, uma seção de uma janela, uma região rectangular seleccionada ou uma região de área livre. Parte de kde-graphics.

  https://github.com/KDE/spectacle/ || spectacle

- Xfce4 Screenshooter — Aplicação e plugin do painel Xfce4 para tirar imagens sobre todo a tela, a janela ativa ou uma região selecionada. Parte de xfce4-goodies.

  https://goodies.xfce.org/projects/applications/xfce4-screenshooter || xfce4-screenshooter

- xwd — Utilitário de dumping de imagem do Sistema X Window

  https://www.x.org/ || xorg-xwd

#### xwd

xwd(1) pertence ao pacote xorg-xwd.

Fazer uma captura da tela inteira:

    $ xwd -root -out screenshot.xwd

Tip Para adicionar delay antes da captura, use o `sleep` comando. Por exemplo: `sleep 5; xwd ...`.

#### scrot

scrot permite tirar capturas de tela via linha de comando e oferece características como um atraso de tempo definido pelo usuário. Salvo instruções em contrário, guarda o arquivo no diretório de trabalho atual.

    $ scrot -t 20 -d 5

O comando acima salva um arquivo .png, juntamente com uma miniatura (20% do original), para publicação na Web. Fornece um atraso de 5 segundos antes de ser capturado neste caso.

Também pode usar formatação padrão de data e hora ao salvar em um arquivo. por exemplo.,

    $ scrot ~/screenshots/%Y-%m-%d-%T-screenshot.png

guarda a captura de tela em um nome de arquivo com o ano, mês, data, horas, minutos e segundos atuais para uma pasta no seu diretório pessoal chamada "screenshots".

Veja scrot(1) para mais informações.

Note Em alguns gerenciadores de janelas como (dwmAUR, xmonad e possivelmente outros) scrot -s não funciona corretamente ao executar através do atalho de teclado do gerenciador de janelas, isso pode ser contornado acrescentando na inicialização do scrot com uma pequena pausa sleep 0.2; scrot -s.

.}}

#### escrotum

escrotum-gitAUR Captura de tela usando PyGTK, inspirado no scrot

Criado porque o scrot tem falhas quando o modo de seleção é usado com janelas em atualização.

Como a interface da linha de comando é quase a mesma que o scrot, pode ser usada como um substituto da mesma.

#### maim

maim Tem o objetivo de ser um scrot melhorado.

Salva a tela completa para arquivo:

    $ maim filename

Comando para seleção e salvar para o arquivo:

    $ maim --select filename

Salvar a janela ativa em um arquivo, assumindo que xdotool está instalado:

    $ maim --window $(xdotool getactivewindow) filename

Comando para seleção, salvar sem cursor, e guardar na área de transferência, assumindo que xclip} está instalado:

    $ maim -s | xclip -selection clipboard -t image/png -i

### Específicos de ambientes de trabalho

#### Spectacle

Se você usa KDE, Você talvez queira usar `Spectacle`.

Spectacle pertence ao pacote spectacle.

#### Xfce Screenshooter

Se você usa Xfce você pode usar xfce4-screenshooter e pode adiconar uma tecla de atalho:

Xfce Menu > Settings > Keyboard > Application Shortcuts

Se você quer pular o aviso de captura, escreva `$ xfce4-screenshooter -h` no terminal para mais opções.

#### GNOME

GNOME usuários podem ultilizar o atalho `PrintScreen` ou clicar no icone da câmera no menu do sistema. De forma opicional você pode instalar o pacote gnome-screenshot e abrir via Apps > Accessories > Take Screenshot.

O GNOME oferece de gravação de tela integrada com a combinação de teclas `Ctrl+Shift+Alt+r`}. Um círculo vermelho é exibido no canto inferior direito da tela quando a gravação está em andamento. Depois de terminada a gravação, um arquivo chamado `Screencast de %d%u-%c.webm`} é guardado no diretório {ic|Videos}}. Para utilizar a função screencast, os pacotes gst-plugin-pipewire} e gst-plugins-good} precisam de ser instalados.

#### Cinnamon

A instalação padrão de Cinnamon não fornece um utilitário de captura de tela. A instalação de gnome-screenshot} irá permitir capturas de tela através do Menu > Acessórios > Screenshot ou com a tecla de atalho `PrintScreen`}.

#### Outros ambientes de trabalho ou gerenciadores de janela

Para outros ambientes de trabalho como LXDE ou gerenciadores de janelas como Openbox e Compiz, é possível adicionar os comandos acima à tecla de atalho para tirar uma captura de tela. Por exemplo,

    $ import -window root ~/Pictures/$(date '+%Y%m%d-%H%M%S').png

Note-se que import faz parte do pacote imagemagick. Adicionar o comando acima à tecla `PrintScreen`} ao Compiz permite levar a captura de tela para a pasta Pictures de acordo com a data e hora. Note que o arquivo `rc.xml` no Openbox não compreende vírgulas; assim, para ligar esse comando à tecla {ic|PrintScreen}}} no Openbox, é necessário adicionar o seguinte à secção do teclado do seu ficheiro {ic|rc.xml}}:

    rc.xml

    <!-- Screenshot -->
        <keybind key="Print">
          <action name="Execute">
            <command>sh -c "import -window root ~/Pictures/$(date '+%Y%m%d-%H%M%S').png"</command>
          </action>
        </keybind>

Se o `Print` acima não funcionar, veja Entrada do teclado e usar diferentes keyym ou keycode.

### Pacotes que incluem função de captura

#### ImageMagick/GraphicsMagick

Veja ImageMagick#Screenshot taking.

#### GIMP

Você também pode realizar capturas de tela com GIMP (File > Create > Screenshot...).

#### imlib2

imlib2 fornece um `imlib2_grab` binário para tirar print. Para tirar uma captura de tela da tela inteira, digite:

    $ imlib2_grab screenshot.png

#### FFmpeg

Veja FFmpeg#Screen capture.

## Screencast software

Veja também FFmpeg#Screen capture e Wikipedia:Comparison of screencasting software.

Os utilitários Screencast permitem que você crie um vídeo de sua área de trabalho ou janelas individuais.

- Byzanz — Aplicativo simples de transmissão que permite criar gifs.

  https://gitlab.gnome.org/Archive/byzanz || byzanz[link quebrado: package not found]

- Deepin Screen Recorder — Gravador de tela para Deepin desktop.

  https://www.deepin.org/en/original/deepin-screen-recorder/ || deepin-screen-recorder

- FFcast — Gravador de tela usando ffmpeg escrito em bash.

  https://github.com/lolilolicon/FFcast || ffcastAUR

- GPU Screen Recorder — Gravador de tela que captura sua tela na GPU apenas para melhorar enormemente o desempenho, comparável ao Nvidia ShadowPlay. Suporta streaming ao vivo e buffer de replay também.

  https://git.dec05eba.com/gpu-screen-recorder-gtk/about/ || gpu-screen-recorder-gtk-gitAUR

- Green Recorder — Simples e funcional gravador de tela para desktop.

  https://github.com/dvershinin/green-recorder || green-recorderAUR

- Kazam — Programa de gravação com o design em mente. Lida com configurações de várias telas.

  https://launchpad.net/kazam || kazamAUR

- Kooha — Gravador de tela simples com interface minimalista em GTK.

  https://github.com/SeaDve/Kooha || kooha

- menyoki — Screen{shot,cast} e realiza ImageOps via linha de comando.

  https://github.com/orhun/menyoki || menyoki

- Open Broadcaster Software — Aplicativo para gravação e transmissão.

  https://obsproject.com/ || obs-studio
  - obs-gnome-screencastAUR – plugin para GNOME screencast, suporta Wayland

- Peek — Ferramenta simples de transmissão de tela que produz animações GIF, APNG, WebM ou MP4. Não mais em desenvolvimento (Jan 2023).

  https://github.com/phw/peek || peek

- RecApp — Screencaster de fácil utilização escrito em GTK. Usando módulos GStreamer gratuitos e não dependentes de FFmpeg. Não está mais em desenvolvimento..

  https://github.com/amikha1lov/RecApp || recapp-gitAUR

- RecordItNow — Plugin based desktop recorder para KDE 4.

  https://recorditnow.sourceforge.net/ || recorditnowAUR[link quebrado: package not found]

- RecordMyDesktop — Utilitário fácil de usar que registra sua área de trabalho no formato ogg com uma interface CLI, GTK ou Qt. (desenvolvimento inativo)

  https://recordmydesktop.sourceforge.net/ || CLI: recordmydesktop, GTK: gtk-recordmydesktopAUR[link quebrado: package not found], Qt: qt-recordmydesktopAUR[link quebrado: package not found]

- screencast — Interface de linha de comando para gravar um desktop X11 usando FFmpeg, tendo suporte para gravação offline e transmissão ao vivo.

  https://github.com/dbermond/screencast/ || screencastAUR

- Screencast — Gravador de screencast simples projetado para Elementary OS.

  https://github.com/artemanufrij/screencast || pantheon-screencastAUR

- SimpleScreenRecorder — Gravador de tela rico em recursos escrito em C++/Qt5 que suporta X11 e OpenGL.

  https://www.maartenbaert.be/simplescreenrecorder/ || simplescreenrecorderAUR

- VokoScreen — Ferramenta GUI simples de screencast usando GStreamer.

  https://linuxecke.volkoh.de/vokoscreen/vokoscreen.html || vokoscreen

- Wayfarer — Gravador de tela em GTK para GNOME / Wayland / Pipewire.

  https://github.com/stronnag/wayfarer || wayfarerAUR

- XVidCap — Aplicação utilizada para gravar um screencast ou gravação digital de uma saída de tela do Sistema X Window com uma narração de áudio.

  https://xvidcap.sourceforge.net/ || xvidcapAUR[link quebrado: package not found]

## Wayland

A captura da tela em compositor baseado em Wlroots pode ser feita usando grim ou grimshotAUR[link quebrado: package not found]} (o pacote sway} também fornece grimshot em `/usr/share/sway/scripts/`) para capturas de tela e wf-recorder} (ou wf-recorder-gitAUR}) para vídeo; wlrobs-hgAUR} é um plugin obs-studio} que permite a captura de telas em compositores baseados em wlroots. Opcionalmente, o slurp pode ser usado para selecionar a parte da tela a ser capturada.

Tirar uma print da tela inteira:

    $ grim screenshot.png

Tirar uma print da janela atual:

    $ grim -g "$(swaymsg -t get_tree | jq -r '.. | select(.focused?) | .rect | "\(.x),\(.y) \(.width)x\(.height)"')" screenshot.png

Tirar uma print de uma área da tela:

    $ grim -g "$(slurp)" screenshot.png

Tirar uma print da tela e enviando para área de transferência usando wl-clipboard}:

    $ grim -g "$(slurp)" - | wl-copy

Gravar um video da tela:

    $ wf-recorder -f recording.mp4

Gravar um video de uma área da tela:

    $ wf-recorder -g "$(slurp)"

Tip

- slurpshot é uma captura de tela interativa que utiliza bemenu.
- Para usar uma ferramenta de edição e desenho de imagem de tela pós-captura, como swappy: `grim -g "$(slurp)" - | swappy -f -`

Além disso, alguns programas mencionados acima funcionam em Wayland (por exemplo, ksnip, green-recorderAUR}). Para que o KDE's spectacle funcione corretamente, você pode ter que excluir ~/.local/share/applications/org.kde.spectacle.desktop; em qualquer caso, Spectacle deve funcionar com Window Under Cursor (Meta+Ctrl+Print) selecionado em Caption Mode Area.

### Screencasting

#### Via GNOME screencast

green-recorderAUR, obs-gnome-screencastAUR e obs-studio suporta gravação de tela no Wayland usando o recurso de transmissão de tela do GNOME.

#### Através de uma webcam virtual de vídeo

Veja v4l2loopback#Casting Wayland using wf-recorder.

Tip

- Este método foi testado com zoomAUR (cliente desktop rodando sob xorg-xwayland} e BigBlueButton sob chromium}) (sob firefox a resolução é realmente baixa); skypeforlinux-binAUR[link quebrado: package not found] detecta o dispositivo de vídeo virtual `VirtualVideoDevice`, mas emite uma tela em branco.
- O exemplo usa `wf-recorder`} mas você pode usar qualquer software, basta alimentar a saída para o dispositivo virtual.

Instale wf-recorder} (ou wf-recorder-gitAUR}) e v4l2loopback-dkms}}. Carregue o módulo de kernel v4l2loopback com os seguintes parâmetros:

    # modprobe v4l2loopback exclusive_caps=1 card_label=VirtualVideoDevice

Verificar se foi criado um novo dispositivo de vídeo virtual `VirtualVideoDevice`:

    $ v4l2-ctl --list-devices

    ...
    VirtualVideoDevice (platform:v4l2loopback-000):
    	/dev/video2
    ...

Comece a gravar a tela com `wf-recorder`} e alimente a saída para o novo dispositivo de vídeo virtual `VirtualVideoDevice`} criado por `v4l2loopback`}:

    $ wf-recorder --muxer=v4l2 --codec=rawvideo --file=/dev/video2 -x yuv420p

O espaço de cor `yuv420p` é necessário para que a saída de vídeo seja compatível com o Zoom [1].

Tip Se você encontrar `Unknown V4L2 pixel format equivalent for rgb0`} executar `wf-recorder`} com `--force-yuv`} ou `-t`} para forçar a conversão dos dados para o formato yuv, antes de enviá-los para a GPU. [2]

Agora você pode selecionar o dispositivo de vídeo virtual acima como sua "webcam" em aplicações de videochamada/video conferência (o dispositivo é chamado `VirtualVideoDevice`). Você pode usar `ffplay`} (parte de ffmpeg}, mpv, ou `gst-launch`} (parte do gstreamer) para verificar se o dispositivo de vídeo virtual de fato produz seu screenshare:

    $ ffplay /dev/video2

    $ mpv av://v4l2:/dev/video2

    $ gst-launch-1.0 -v v4l2src device=/dev/video2 ! glimagesink

Se o Firefox não conseguir ler o fluxo de vídeo e imprimir uma mensagem como "AbortError": Falha no início do vídeo", tente pré-carregar `v4l2compat.so`}:

    $ LD_PRELOAD=/usr/lib/v4l1compat.so firefox

##### Compartilhando aplicações individualmente

Warning Este método não envolve uma implementação adequada de compartilhamento de aplicações individuais, pois a região que está sendo compartilhada não mudará após o redimensionamento de nenhuma janela.

Como explicado acima, `wf-recorder`} é capaz de gravar apenas uma parte da tela selecionando primeiro uma região com slurp}. Para usar esta funcionalidade para compartilhar uma região/janela de aplicação específica através de um dispositivo de vídeo virtual, comece a gravar a tela com o seguinte comando modificado:

    $ wf-recorder -g "$(slurp)" --muxer=v4l2 --codec=rawvideo --file=/dev/video2 -x yuv420p

Após selecionar uma região da tela, você poderá acessar o fluxo de vídeo através do dispositivo de vídeo virtual `/dev/video2` como acima.

#### Via o protocolo WebRTC

Note Este método só permite compartilhar uma produção inteira e não aplicações individuais [3].

Veja PipeWire#WebRTC screen sharing.

Chromium e Firefox devem agora poder acessar o compartilhamento de tela. Você pode verificar isto através de Mozilla's getUserMedia / getDisplayMedia Test Page.

## Terminal

This article or section needs expansion.

Reason: Adicionar subseção sobre terminal recorders (e.g. asciinema). (Discuss in Talk:Screen capture (Português))

### Captura com códigos ANSI

Você pode usar o comando script(1)}, parte do pacote util-linux}. Basta executar o comando `script` e a partir desse momento, toda a saída será salva no arquivo `typescript`, incluindo os códigos ANSI.

Uma vez terminado, basta executar o `exit` e o `typescript`} estaria pronto. O arquivo resultante pode ser convertido para HTML usando o pacote ansi2htmlAUR (não confundir com ansi2html de python-ansi2html).

Para converter o arquivo `typescript` para `typescript.html`, faça o seguinte:

    $ ansi2html --bg=dark < typescript > typescript.html

Atualmente, os comandos 'some podem ser canalizados diretamente para ansi2html:

    $ ls --color|ansi2html --bg=dark >output.html

Isso não funciona em todos os casos, portanto, nesses casos, é obrigatório usar `script`.

### Framebuffer

Instale o framebuffer e use fbgrab ou fbdumpAUR para fazer uma captura de tela.

### Console Virtual

Se você quiser apenas capturar o texto no console e não uma imagem real, você pode usar `setterm`}, que faz parte do pacote util-linux}. O seguinte comando irá despejar o conteúdo textual do console virtual 1 em um arquivo `screen.dump`} no diretório atual:

    # setterm -dump 1 -file screen.dump

A permissão de root é necessária porque o conteúdo de `/dev/vcs1` precisa ser lido.

Categories:

- System administration (Português)
- Multimedia (Português)

Hidden categories:

- Pages with broken package links
- Pages or sections flagged with Template:Expansion

Screen capture (Português)
Add topic